@sjcrh/proteinpaint-client 2.210.0 → 2.210.1

package/dist/chunk-AB6JQFIQ.js

@@ -0,0 +1,129 @@
+import {
+  keyupEnter
+} from "./chunk-CSAS3PVJ.js";
+
+// src/block.mds.svcnv.share.js
+function rnabamtk_initparam(c) {
+  if (!c.dna_mintotalreads) c.dna_mintotalreads = 8;
+  if (!c.rna_mintotalreads) c.rna_mintotalreads = 8;
+  if (!c.hetsnp_minbaf) c.hetsnp_minbaf = 0.3;
+  if (!c.hetsnp_maxbaf) c.hetsnp_maxbaf = 0.7;
+  if (c.rnapileup_q == void 0) c.rnapileup_q = 0;
+  if (!c.rnapileup_Q) c.rnapileup_Q = 13;
+  if (!c.binompvaluecutoff) c.binompvaluecutoff = 0.05;
+  if (!c.clientcolor_snpinuse) c.clientcolor_snpinuse = "blue";
+  if (!c.clientcolor_markernotinuse) c.clientcolor_markernotinuse = "#bbb";
+}
+function configPanel_rnabam(tk, block, loadTk) {
+  const c = tk.checkrnabam;
+  if (!c) return;
+  tk.tkconfigtip.d.append("hr");
+  const d = tk.tkconfigtip.d.append("div").style("margin", "15px 0px");
+  d.append("div").style("opacity", 0.5).style("font-size", ".9em").text("Finding heterozygous SNPs in DNA");
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("DNA minimum total read count ");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.dna_mintotalreads).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.dna_mintotalreads == v) {
+        return;
+      }
+      c.dna_mintotalreads = v;
+      loadTk(tk, block);
+    });
+    row.append("div").style("opacity", ".5").style("font-size", ".8em").text("If a SNP's total coverage is below cutoff, it will be skipped.");
+  }
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("Heterozygous SNP BAF range&nbsp;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.hetsnp_minbaf).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.hetsnp_minbaf == v) {
+        return;
+      }
+      c.hetsnp_minbaf = v;
+      loadTk(tk, block);
+    });
+    row.append("span").style("opacity", ".5").style("font-size", ".8em").html("&nbsp;&leq; BAF &leq;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.hetsnp_maxbaf).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.hetsnp_maxbaf == v) {
+        return;
+      }
+      c.hetsnp_maxbaf = v;
+      loadTk(tk, block);
+    });
+    row.append("div").style("opacity", ".5").style("font-size", ".8em").text("If a SNP's BAF (B-allele fraction) is within this range, it is heterozygous.");
+  }
+  d.append("div").style("margin-top", "20px").style("opacity", 0.5).style("font-size", ".9em").text("Counting alleles in RNA-seq BAM file");
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("Skip alignments with mapQ smaller than&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.rnapileup_q).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v < 0) return;
+      if (c.rnapileup_q == v) {
+        return;
+      }
+      c.rnapileup_q = v;
+      loadTk(tk, block);
+    });
+  }
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("Skip bases with baseQ/BAQ smaller than&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.rnapileup_Q).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.rnapileup_Q == v) {
+        return;
+      }
+      c.rnapileup_Q = v;
+      loadTk(tk, block);
+    });
+  }
+  d.append("div").style("margin-top", "20px").style("opacity", 0.5).style("font-size", ".9em").text("Binomial test on whether a heterozygous SNP shows allelic bias in RNA");
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("P-value cutoff&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.binompvaluecutoff).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0 || v >= 1) return;
+      if (c.binompvaluecutoff == v) {
+        return;
+      }
+      c.binompvaluecutoff = v;
+      loadTk(tk, block);
+    });
+  }
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("RNA minimum total read count&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.rna_mintotalreads).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.rna_mintotalreads == v) {
+        return;
+      }
+      c.rna_mintotalreads = v;
+      loadTk(tk, block);
+    });
+    row.append("div").style("opacity", ".5").style("font-size", ".8em").text("If a SNP's total read count from RNA is below cutoff, it won't do binomial test.");
+  }
+}
+
+export {
+  rnabamtk_initparam,
+  configPanel_rnabam
+};
+//# sourceMappingURL=chunk-AB6JQFIQ.js.map

package/dist/chunk-ACOHIDWO.js

@@ -0,0 +1,240 @@
+import {
+  make_radios
+} from "./chunk-CSAS3PVJ.js";
+import {
+  initBinConfig
+} from "./chunk-VTHZGUSZ.js";
+import {
+  toStoredUnit,
+  toUserUnit
+} from "./chunk-W5J3LTYS.js";
+import {
+  format
+} from "./chunk-4OLM3KSB.js";
+
+// termsetting/handlers/NumRegularBinEditor.ts
+var NumRegularBinEditor = class {
+  constructor(editHandler) {
+    this.dom = {};
+    this.editHandler = editHandler;
+    this.opts = editHandler.opts;
+    this.tw = editHandler.tw;
+    this.termsetting = editHandler.termsetting;
+  }
+  /* q holds bin boundaries in the unit the term's values are stored in, while the <input>s and the
+  density plot show them in the term's user-facing unit. toDisplay()/toStored() cross that boundary;
+  both are identity functions unless the term declares valueConversion{} */
+  toDisplay(v) {
+    return toUserUnit(v, this.tw.term);
+  }
+  toStored(v) {
+    return toStoredUnit(v, this.tw.term);
+  }
+  render(div) {
+    this.tw = this.editHandler.tw;
+    const isRemounting = !!this.dom.binsTable && this.editHandler.dom.binsDiv?.node().contains(this.dom.binsTable.node());
+    if (!isRemounting) this.q = this.getDefaultQ();
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+    if (isRemounting) return;
+    if (this.dom.binsTable) {
+      this.dom.binsTable.remove();
+      delete this.dom.binsTable;
+    }
+    const binsTable = div.append("table");
+    this.dom.binsTable = binsTable;
+    this.renderBinSizeInput(binsTable.append("tr"));
+    this.renderFirstBinInput(binsTable.append("tr"));
+    this.renderLastBinInputs(binsTable.append("tr"));
+  }
+  getDefaultQ() {
+    if (this.tw.q.type == "regular-bin") return JSON.parse(JSON.stringify(this.tw.q));
+    const t = this.tw.term;
+    const defaultQ = this.termsetting.opts.use_bins_less && t.bins?.less || t.bins?.default;
+    if (defaultQ) return JSON.parse(JSON.stringify(defaultQ));
+    const binConfig = initBinConfig(this.editHandler.handler.density_data);
+    return typeof binConfig == "string" ? JSON.parse(binConfig) : binConfig;
+  }
+  renderBinSizeInput(tr) {
+    const handler = this.editHandler.handler;
+    tr.append("td").style("margin", "5px").style("opacity", 0.5).text("Bin Size");
+    const { min, max } = handler.density_data;
+    const q = this.q;
+    const origBinSize = this.toDisplay(q.bin_size);
+    this.dom.bin_size_input = tr.append("td").append("input").attr("type", "number").attr(
+      "value",
+      handler.density.scaleFactor == 1 && "rounding" in q ? format(q.rounding || ".0f")(q.bin_size) : origBinSize
+    ).attr("data-testid", "sjpp-num-reg-bin-editor-size").style("margin-left", "15px").style("width", "100px").style("color", () => q.bin_size > Math.abs(max - min) ? "red" : "").on("change", (event) => {
+      const newValue = this.toStored(Number(event.target.value));
+      if (newValue <= 0) {
+        window.alert("Please enter non-negative bin size.");
+        event.target.value = origBinSize;
+        return;
+      }
+      if ((max - min) / newValue > 100) {
+        window.alert("Bin size too small. Try setting a bigger value.");
+        event.target.value = origBinSize;
+        return;
+      }
+      q.bin_size = newValue;
+      this.dom.bin_size_input.style(
+        "color",
+        q.bin_size > max - min ? "red" : this.toDisplay(newValue) != origBinSize ? "green" : ""
+      );
+      handler.density.setBinLines(this.getBoundaryOpts());
+    });
+  }
+  renderFirstBinInput(tr) {
+    const handler = this.editHandler.handler;
+    const q = this.q;
+    if (!q.first_bin) throw "missing q.first_bin";
+    tr.append("td").style("margin", "5px").style("opacity", 0.5).text("First Bin Stop");
+    const { min, max } = handler.density_data;
+    const origValue = this.toDisplay(q.first_bin.stop);
+    this.dom.first_stop_input = tr.append("td").append("input").attr("type", "number").property("value", origValue).style("width", "100px").style("margin-left", "15px").on("change", (event) => {
+      const newValue = this.toStored(Number(event.target.value));
+      if (Number(event.target.value) < this.toDisplay(min) || Number(event.target.value) > this.toDisplay(max)) {
+        window.alert("First bin stop value out of bound.");
+        event.target.value = origValue;
+        return;
+      }
+      this.q.first_bin.stop = newValue;
+      handler.density.setBinLines(this.getBoundaryOpts());
+    });
+    tr.append("td").append("div").style("font-size", ".6em").style("opacity", 0.5).style("display", handler.density.no_density_data ? "none" : "block").text("Indicated by left-most red line. Drag to change.");
+  }
+  renderLastBinInputs(tr) {
+    const handler = this.editHandler.handler;
+    const q = this.q;
+    const isAuto = !q.last_bin || !Number.isFinite(q.last_bin.start);
+    tr.append("td").style("padding-top", "4px").style("opacity", 0.5).style("vertical-align", "top").text("Last Bin Start");
+    const td1 = tr.append("td").style("padding-left", "15px").style("vertical-align", "top");
+    const radio_div = td1.append("div");
+    const radios = make_radios({
+      holder: radio_div,
+      options: [
+        { label: "Automatic", value: "auto", checked: isAuto },
+        { label: "Fixed", value: "fixed", checked: !isAuto }
+      ],
+      callback: (v) => {
+        if (v == "auto") {
+          delete q.last_bin;
+          edit_div.style("display", "none");
+          handler.density.setBinLines(this.getBoundaryOpts());
+          return;
+        }
+        edit_div.style("display", "inline-block");
+        if (this.dom.last_start_input.property("value") == "") {
+          this.dom.last_start_input.property(
+            "value",
+            this.toDisplay(this.tw.q.last_bin?.start || handler.density_data.max)
+          );
+        }
+        this.setLastBinStart();
+      }
+    });
+    this.dom.fixed_radio = radios.inputs.filter((_, i) => i === 1);
+    const edit_div = tr.append("td").append("div").style("display", isAuto ? "none" : "inline-block");
+    this.dom.last_start_input = edit_div.append("input").attr("type", "number").property("value", Number.isFinite(q.last_bin?.start) ? this.toDisplay(q.last_bin.start) : "").style("width", "100px").on("change", () => this.setLastBinStart());
+    edit_div.append("div").style("font-size", ".6em").style("opacity", 0.5).style("display", handler.density.no_density_data ? "none" : "block").text("Indicated by right-most red line. Drag to change.");
+  }
+  setLastBinStart() {
+    const q = this.q;
+    const { max } = this.editHandler.handler.density_data;
+    const strInput = this.dom.last_start_input.property("value");
+    if (strInput === "") return;
+    const inputValue = this.toStored(Number(strInput));
+    if (q.first_bin && Number(strInput) <= this.toDisplay(q.first_bin.stop)) {
+      window.alert("Last bin start cannot be smaller than first bin stop.");
+      this.dom.last_start_input.property("value", this.toDisplay(max));
+      return;
+    }
+    if (Number(strInput) > this.toDisplay(max)) {
+      window.alert("Last bin start value out of bound.");
+      this.dom.last_start_input.property("value", this.toDisplay(max));
+      return;
+    }
+    if (q.last_bin) q.last_bin.start = inputValue;
+    else
+      q.last_bin = {
+        start: inputValue,
+        stopunbounded: true,
+        stopinclusive: false
+      };
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+  getBoundaryOpts() {
+    const { min, max } = this.editHandler.handler.density_data;
+    const binLinesStop = this.q.last_bin?.start ?? max + Math.abs(this.q.first_bin.stop) - Math.min(min, 0);
+    const boundaryValues = [];
+    for (let i = this.q.first_bin.stop; i <= binLinesStop; i = i + this.q.bin_size) {
+      if (this.q.last_bin?.start === i) break;
+      if (i > binLinesStop) boundaryValues[boundaryValues.length - 1].isLastVisibleLine = true;
+      const isDraggable = i === this.q.first_bin.stop || i === this.q.bin_size - 1;
+      boundaryValues.push({ x: this.toDisplay(i), isDraggable, movesWithLineIndex: !isDraggable ? 0 : -1 });
+    }
+    if (this.q.last_bin) {
+      boundaryValues.push({
+        x: this.toDisplay(this.q.last_bin.start),
+        isDraggable: true,
+        isLastVisibleLine: true,
+        movesWithLineIndex: -1
+      });
+    }
+    return {
+      values: boundaryValues,
+      // the dragged value arrives in display units, matching what the <input>s show
+      callback: (d, value) => {
+        if (d.index === 0) {
+          this.dom.first_stop_input.property("value", value);
+          this.q.first_bin.stop = this.toStored(value);
+        } else {
+          this.dom.last_start_input.property("value", value);
+          if (this.q.last_bin) this.q.last_bin.start = this.toStored(value);
+        }
+      }
+    };
+  }
+  getEditedQ(destroyDom = true) {
+    const bin_size = this.dom.bin_size_input.property("value");
+    const config = {
+      mode: "discrete",
+      type: "regular-bin",
+      startinclusive: this.editHandler.boundaryInclusion == "startinclusive",
+      stopinclusive: this.editHandler.boundaryInclusion == "stopinclusive",
+      bin_size: this.toStored(Number(bin_size)),
+      first_bin: {
+        startunbounded: true,
+        stop: this.toStored(Number(this.dom.first_stop_input.property("value")))
+      },
+      /* rounding formats the stored bin size, so it cannot be derived from the decimals of a
+      converted input. a converted term labels its bins through valueConversion instead */
+      rounding: this.editHandler.handler.density.scaleFactor != 1 ? ".0f" : bin_size.includes(".") && !bin_size.endsWith(".") ? `.${bin_size.split(".")[1].length}f` : ".0f"
+    };
+    if (this.dom.fixed_radio.property("checked")) {
+      config.last_bin = {
+        start: this.toStored(Number(this.dom.last_start_input.property("value"))),
+        stopunbounded: true
+      };
+    }
+    if (destroyDom) {
+      for (const name of Object.keys(this.dom)) {
+        this.dom[name].remove();
+        delete this.dom[name];
+      }
+    }
+    return config;
+  }
+  undoEdits() {
+    this.q = this.getDefaultQ();
+    this.dom.binsTable.selectAll("*").remove();
+    this.renderBinSizeInput(this.dom.binsTable.append("tr"));
+    this.renderFirstBinInput(this.dom.binsTable.append("tr"));
+    this.renderLastBinInputs(this.dom.binsTable.append("tr"));
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+};
+
+export {
+  NumRegularBinEditor
+};
+//# sourceMappingURL=chunk-ACOHIDWO.js.map

package/dist/chunk-AIVPAC5Q.js

@@ -0,0 +1,102 @@
+import {
+  addGeneSearchbox,
+  first_genetrack_tolist,
+  getDNAMethUnit,
+  sayerror
+} from "./chunk-CSAS3PVJ.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  DNA_METHYLATION
+} from "./chunk-UYKJOBRO.js";
+
+// termdb/handlers/dnaMethylation.ts
+var SearchHandler = class {
+  init(opts) {
+    this.opts = opts;
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("margin", "10px 0px");
+    this.dom = {};
+    this.dom.errDiv = holder.append("div").style("margin", "5px 0px").style("display", "none");
+    this.dom.geneSearchDiv = holder.append("div");
+    this.dom.blockDiv = holder.append("div").style("display", "none").style("margin", "15px 4px");
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: this.dom.geneSearchDiv,
+      callback: async () => {
+        try {
+          this.dom.errDiv.style("display", "none");
+          await this.handleGeneSearch(geneSearch);
+        } catch (e) {
+          this.dom.errDiv.style("display", "block");
+          sayerror(this.dom.errDiv, "Error: " + (e.message || e));
+          if (e.stack) console.log(e.stack);
+        }
+      }
+    });
+  }
+  async handleGeneSearch(geneSearch) {
+    if (geneSearch.geneSymbol) {
+      const { chr, start, stop } = geneSearch;
+      if (!chr || !Number.isInteger(start) || !Number.isInteger(stop))
+        throw new Error("unable to retrieve gene coordinate");
+      this.dom.blockDiv.selectAll("*").remove();
+      this.dom.blockDiv.style("display", "block");
+      this.dom.blockDiv.append("div").style("opacity", 0.6).text("Navigate genome browser to desired region");
+      const arg = {
+        holder: this.dom.blockDiv,
+        genome: this.opts.genomeObj,
+        // genome obj
+        chr,
+        start,
+        stop,
+        tklst: [],
+        nobox: true,
+        width: 500,
+        hidegenelegend: true,
+        debugmode: this.opts.debug
+      };
+      first_genetrack_tolist(this.opts.genomeObj, arg.tklst);
+      const _ = await import("./block-GEG4UUOU.js");
+      this.blockInstance = new _.Block(arg);
+      this.dom.submitBtn = this.dom.blockDiv.append("div").attr("data-testid", "sjpp-dnaMethylation-submitDiv").style("margin", "10px 0px").append("button").style("border", "none").style("border-radius", "20px").style("padding", "10px 15px").text("Submit Region").on("click", async () => {
+        const { chr: chr2, start: start2, stop: stop2 } = this.blockInstance.rglst[0];
+        const term = this.makeTerm({ chr: chr2, start: start2, stop: stop2 });
+        await this.callback(term);
+      });
+    } else if (geneSearch.chr && Number.isInteger(geneSearch.start) && Number.isInteger(geneSearch.stop)) {
+      const { chr } = geneSearch;
+      let { start, stop } = geneSearch;
+      if (geneSearch.actualposition?.len <= 1) {
+        start = geneSearch.actualposition.position;
+        stop = start + 1;
+      }
+      const term = this.makeTerm({ chr, start, stop });
+      await this.callback(term);
+    } else {
+      throw new Error("invalid gene search input");
+    }
+  }
+  makeTerm(opts) {
+    const { chr, start, stop } = opts;
+    if (!chr || !Number.isInteger(start) || !Number.isInteger(stop)) throw new Error("invalid coordinate");
+    const unit = getDNAMethUnit("region", this.app.vocabApi);
+    const term = {
+      chr,
+      start,
+      stop,
+      type: DNA_METHYLATION,
+      unit,
+      genomicFeatureType: "region"
+    };
+    return term;
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-AIVPAC5Q.js.map