@sjcrh/proteinpaint-client 2.225.0 → 2.227.0

package/dist/chunk-6CV3YVJD.js

@@ -0,0 +1,194 @@
+import {
+  violinRenderer
+} from "./chunk-YBXQBSFY.js";
+import {
+  getValueConversionFactor
+} from "./chunk-W5J3LTYS.js";
+import {
+  linear
+} from "./chunk-4OLM3KSB.js";
+import {
+  drag_default
+} from "./chunk-5R63Q5KH.js";
+import {
+  pointer_default,
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// termsetting/handlers/NumericDensity.ts
+var NumericDensity = class {
+  constructor(opts) {
+    this.dom = {};
+    // WeakMap allows deletion of value when the object/DOM key is deleted,
+    // so better for avoiding memory leak
+    this.vrByDiv = /* @__PURE__ */ new WeakMap();
+    this.ranges = [];
+    this.no_density_data = false;
+    this.brushes = [];
+    this.plot_size = {
+      width: 500,
+      height: 100,
+      xpad: 10,
+      ypad: 20,
+      radius: 8
+    };
+    this.opts = opts;
+    this.termsetting = opts.termsetting;
+    this.tw = opts.termsetting.tw;
+  }
+  /* the boundary values exchanged with the bin/knot editors, and the domain of this.xscale, are in
+  	the term's user-facing unit; density_data is in the unit the values are stored in. only the two
+  	getters below cross that line, to put the plot's endpoints in the same unit as those values.
+  
+  	they multiply instead of calling toUserUnit(), which rounds: rounding is right for a number shown
+  	in an input, but a rounded domain endpoint distorts every scaled x by up to half of the last shown
+  	digit, and collapses the domain outright when the converted range is smaller than that (a stored
+  	range of under 2 days at scaleFactor=1/365.25). it would also disagree with violinRenderer, whose
+  	axis this plot's lines overlay and which scales its own domain unrounded */
+  get scaleFactor() {
+    return getValueConversionFactor(this.tw.term);
+  }
+  get displayMin() {
+    return this.density_data.min * this.scaleFactor;
+  }
+  get displayMax() {
+    return this.density_data.max * this.scaleFactor;
+  }
+  async setData() {
+    const self = this.termsetting;
+    const d = await self.vocabApi.getViolinBox(
+      {
+        plotType: "violin",
+        tw: { type: self.tw.type, term: self.term, q: self.q },
+        svgw: this.plot_size.width,
+        radius: this.plot_size.radius,
+        filter: self.filter
+      },
+      self.opts.getBodyParams?.()
+    );
+    if (d.error) throw d;
+    this.density_data = d;
+    return this.density_data;
+  }
+  async showViolin(div, boundaryOpts) {
+    await this.setData();
+    if (!this.vrByDiv.has(div)) {
+      div.style("padding", "5px").selectAll("*").remove();
+      const loadingDiv = div.append("div").style("padding", "10px").style("text-align", "center").html("Getting distribution data ...<br/>");
+      const densityDiv = div.append("div");
+      loadingDiv.remove();
+      const vr = new violinRenderer({
+        holder: densityDiv,
+        rd: this.density_data,
+        width: this.plot_size.width,
+        height: this.plot_size.height,
+        radius: this.plot_size.radius,
+        // axis ticks are labeled in the term's user-facing unit, e.g. years and not days
+        scaleFactor: this.scaleFactor
+      });
+      this.vrByDiv.set(div, vr);
+    }
+    this.vr = this.vrByDiv.get(div);
+    this.dom.svg = this.vr.svg;
+    this.vr.render();
+    if (boundaryOpts) await this.setBinLines(boundaryOpts);
+    return this.density_data;
+  }
+  async setBinLines(boundaryOpts) {
+    if (this.density_data.max == this.density_data.min) {
+      this.handleNoDensity();
+    } else {
+      if (this.dom.binsize_g) this.dom.binsize_g.selectAll("*").remove();
+      this.dom.binsize_g = this.dom.svg.append("g").attr("transform", `translate(${this.plot_size.xpad}, ${this.plot_size.ypad})`).attr("class", "binsize_g");
+      const maxvalue = this.displayMax;
+      const minvalue = this.displayMin;
+      this.xscale = linear().domain([minvalue, maxvalue]).range([this.plot_size.xpad, this.plot_size.width + this.plot_size.xpad]);
+      this.ranges = [];
+      this.brushes = [];
+      this.renderBinLines(boundaryOpts);
+    }
+  }
+  handleNoDensity() {
+    this.no_density_data = true;
+    this.ranges = [];
+    this.brushes = [];
+  }
+  renderBinLines(boundaryOpts) {
+    const { plot_size, tw, xscale, scaleFactor } = this;
+    if (!this.density_data) throw `Missing .density_data [density.ts, renderBinLines()]`;
+    const scaledMinX = Math.round(this.xscale(this.displayMin));
+    const scaledMaxX = Math.round(this.xscale(this.displayMax));
+    const lines = [];
+    for (const [index, v] of boundaryOpts.values.entries()) {
+      lines.push({ ...v, index, scaledX: Math.round(this.xscale(v.x)) });
+    }
+    const lastVisibleLine = lines.find((l) => l.isLastVisibleLine);
+    const lastVisibleScaledX = lastVisibleLine ? lastVisibleLine.scaledX : scaledMaxX;
+    const dragger = drag_default().on("drag", onDrag).on("end", onDrag);
+    this.dom.binsize_g.selectAll("line").remove();
+    this.dom.binsize_g.selectAll("line").data(lines).enter().append("line").style("stroke", (d) => d.isDraggable ? "#cc0000" : "#555").style("stroke-width", 1).attr("x1", (d) => d.scaledX).attr("y1", 0).attr("x2", (d) => d.scaledX).attr("y2", plot_size.height).style("cursor", (d) => d.isDraggable ? "ew-resize" : "").attr("display", (d) => !d.isDraggable && d.scaledX > lastVisibleScaledX ? "none" : "").on("mouseover", function(_, d) {
+      if (d.isDraggable) select_default(this).style("stroke-width", 3);
+    }).on("mouseout", function() {
+      select_default(this).style("stroke-width", 1);
+    }).each(function(d) {
+      if (d.isDraggable) select_default(this).call(dragger);
+    });
+    const lineElems = this.dom.binsize_g.node().querySelectorAll("line");
+    function toBoundaryValue(x) {
+      const inverted = xscale.invert(x);
+      return Number(
+        scaleFactor != 1 ? inverted.toFixed(2) : tw.term.type == "integer" ? Math.round(inverted) : inverted.toFixed(3)
+      );
+    }
+    function toLineValue(line) {
+      return line.draggedX === void 0 ? line.x : toBoundaryValue(line.draggedX);
+    }
+    function getNeighbors(d) {
+      const x = d.draggedX ?? d.scaledX;
+      let lower, upper;
+      for (const line of lines) {
+        if (line.index === d.index || !line.isDraggable) continue;
+        const lineX = line.draggedX ?? line.scaledX;
+        if (lineX <= x) {
+          if (!lower || lineX > (lower.draggedX ?? lower.scaledX)) lower = line;
+        } else if (!upper || lineX < (upper.draggedX ?? upper.scaledX)) upper = line;
+      }
+      return [lower, upper];
+    }
+    function onDrag(event, _d) {
+      const d = _d;
+      const [lower, upper] = getNeighbors(d);
+      const lowerX = Math.max(scaledMinX, lower ? lower.draggedX ?? lower.scaledX : scaledMinX);
+      const upperX = Math.min(scaledMaxX, upper ? upper.draggedX ?? upper.scaledX : scaledMaxX);
+      if (upperX - lowerX < 2) return;
+      const draggedX = Math.min(Math.max(pointer_default(event, this)[0], lowerX + 1), upperX - 1);
+      const value = toBoundaryValue(draggedX);
+      if (lower && value === toLineValue(lower)) return;
+      if (upper && value === toLineValue(upper)) return;
+      d.draggedX = draggedX;
+      select_default(this).attr("x1", d.draggedX).attr("y1", 0).attr("x2", d.draggedX).attr("y2", plot_size.height);
+      const lastVisibleScaledX2 = lastVisibleLine?.draggedX ?? lastVisibleLine?.scaledX ?? scaledMaxX;
+      const xOffset = d.draggedX - d.scaledX;
+      if (xOffset) {
+        for (const elem of lineElems) {
+          const c = elem.__data__;
+          if (c.movesWithLineIndex !== d.index) continue;
+          c.draggedX = c.scaledX + xOffset;
+          select_default(elem).attr("x1", c.draggedX).attr("x2", c.draggedX).style("display", c.draggedX >= lastVisibleScaledX2 ? "none" : "");
+        }
+        boundaryOpts.callback(d, value);
+      }
+    }
+  }
+  destroy() {
+    for (const [k, v] of Object.entries(this.dom)) {
+      delete this.dom[k];
+      if (typeof v.remove == "function") v.remove();
+    }
+  }
+};
+
+export {
+  NumericDensity
+};
+//# sourceMappingURL=chunk-6CV3YVJD.js.map

package/dist/chunk-6UHSGC6G.js

@@ -0,0 +1,276 @@
+import {
+  parsesample
+} from "./chunk-VVWZ4BOI.js";
+import {
+  dtfusionrna,
+  dtsv,
+  mclassfusionrna,
+  mclasssv
+} from "./chunk-2N345NXD.js";
+
+// ../shared/utils/dist/src/bulk.sv.js
+function parseheader(line, flag, issv) {
+  const header = line.toLowerCase().split("	");
+  if (header.length <= 1) return "invalid file header for fusions";
+  const htry = (...lst) => {
+    for (const a of lst) {
+      const j = header.indexOf(a);
+      if (j != -1) return j;
+    }
+    return -1;
+  };
+  let i = htry("gene_a", "gene1", "genea");
+  if (i == -1) return "gene_a missing from header";
+  header[i] = "gene1";
+  i = htry("gene_b", "gene2", "geneb");
+  if (i == -1) return "gene_b missing from header";
+  header[i] = "gene2";
+  i = htry("chr_a", "chr1", "chra");
+  if (i == -1) return "chr_a missing from header";
+  header[i] = "chr1";
+  i = htry("chr_b", "chr2", "chrb");
+  if (i == -1) return "chr_b missing from header";
+  header[i] = "chr2";
+  i = htry("pos_a", "position_a", "position1", "posa");
+  if (i == -1) return "pos_a missing from header";
+  header[i] = "position1";
+  i = htry("pos_b", "position_b", "position2", "posb");
+  if (i == -1) return "pos_b missing from header";
+  header[i] = "position2";
+  i = htry("isoform_a", "refseq_a", "refseq1", "isoform1", "sv_refseqa");
+  if (i == -1) return "isoform_a missing from header";
+  header[i] = "isoform1";
+  i = htry("isoform_b", "refseq_b", "refseq2", "isoform2", "sv_refseqb");
+  if (i == -1) return "isoform_b missing from header";
+  header[i] = "isoform2";
+  i = htry("strand_a", "orta");
+  if (i == -1) return "strand_a missing from header";
+  header[i] = "strand1";
+  i = htry("strand_b", "ortb");
+  if (i == -1) return "strand_b missing from header";
+  header[i] = "strand2";
+  i = htry("sample", "sample_name", "tumor_sample_barcode");
+  if (i != -1) header[i] = "sample";
+  i = htry("patient", "donor", "target_case_id");
+  if (i != -1) header[i] = "patient";
+  i = htry("sampletype", "sample type", "sample_type");
+  if (i != -1) header[i] = "sampletype";
+  i = htry("disease");
+  if (i != -1) header[i] = "disease";
+  i = htry("origin");
+  if (i != -1) header[i] = "origin";
+  if (issv) {
+    flag.sv.loaded = true;
+    flag.sv.header = header;
+  } else {
+    flag.fusion.loaded = true;
+    flag.fusion.header = header;
+  }
+  return false;
+}
+function parseline(i, line, flag, issv) {
+  if (line == "" || line[0] == "#") return;
+  const lst = line.split("	");
+  const m = {};
+  const header = issv ? flag.sv.header : flag.fusion.header;
+  const badlines = issv ? flag.sv.badlines : flag.fusion.badlines;
+  for (let j = 0; j < header.length; j++) {
+    m[header[j]] = lst[j];
+  }
+  if (!m.chr1) {
+    badlines.push([i, "missing chr1", lst]);
+    return;
+  }
+  if (m.chr1.toLowerCase().indexOf("chr") != 0) {
+    m.chr1 = "chr" + m.chr1;
+  }
+  if (!m.chr2) {
+    badlines.push([i, "missing chr2", lst]);
+    return;
+  }
+  if (m.chr2.toLowerCase().indexOf("chr") != 0) {
+    m.chr2 = "chr" + m.chr2;
+  }
+  let v = m.position1;
+  if (!v) {
+    badlines.push([i, "missing position1", lst]);
+    return;
+  }
+  let v2 = Number.parseInt(v);
+  if (Number.isNaN(v2) || v2 <= 0) {
+    badlines.push([i, "invalid value for position1", lst]);
+    return;
+  }
+  m.position1 = v2;
+  v = m.position2;
+  if (!v) {
+    badlines.push([i, "missing position2", lst]);
+    return;
+  }
+  v2 = Number.parseInt(v);
+  if (Number.isNaN(v2) || v2 <= 0) {
+    badlines.push([i, "invalid value for position2", lst]);
+    return;
+  }
+  m.position2 = v2;
+  if (parsesample(m, flag, i, lst)) {
+    return;
+  }
+  if (m.isoform1 && m.isoform1.indexOf(",") != -1) {
+    const lst2 = m.isoform1.split(",");
+    m.isoform1 = void 0;
+    for (const t of lst2) {
+      if (t != "") m.isoform1 = t;
+    }
+  }
+  if (m.isoform2 && m.isoform2.indexOf(",") != -1) {
+    const lst2 = m.isoform2.split(",");
+    m.isoform2 = void 0;
+    for (const t of lst2) {
+      if (t != "") m.isoform2 = t;
+    }
+  }
+  if (!m.gene1) {
+    m.isoform1 = void 0;
+  }
+  if (!m.gene2) {
+    m.isoform2 = void 0;
+  }
+  if (m.gene1) {
+    flag.good++;
+    const m2 = {
+      dt: issv ? dtsv : dtfusionrna,
+      class: issv ? mclasssv : mclassfusionrna,
+      isoform: m.isoform1,
+      mname: m.gene2 || m.chr2,
+      sample: m.sample,
+      patient: m.patient,
+      sampletype: m.sampletype,
+      origin: m.origin,
+      disease: m.disease,
+      pairlst: [
+        {
+          a: {
+            name: m.gene1,
+            isoform: m.isoform1,
+            strand: m.strand1,
+            chr: m.chr1,
+            position: m.position1
+          },
+          b: {
+            name: m.gene2,
+            isoform: m.isoform2,
+            strand: m.strand2,
+            chr: m.chr2,
+            position: m.position2
+          }
+        }
+      ]
+    };
+    const n = flag.geneToUpper ? m.gene1.toUpperCase() : m.gene1;
+    if (!flag.data[n]) {
+      flag.data[n] = [];
+    }
+    flag.data[n].push(m2);
+  }
+  if (m.gene2 && m.gene2 != m.gene1) {
+    flag.good++;
+    const m2 = {
+      dt: issv ? dtsv : dtfusionrna,
+      class: issv ? mclasssv : mclassfusionrna,
+      isoform: m.isoform2,
+      mname: m.gene1 || m.chr1,
+      sample: m.sample,
+      patient: m.patient,
+      sampletype: m.sampletype,
+      origin: m.origin,
+      disease: m.disease,
+      pairlst: [
+        {
+          a: {
+            name: m.gene1,
+            isoform: m.isoform1,
+            strand: m.strand1,
+            chr: m.chr1,
+            position: m.position1
+          },
+          b: {
+            name: m.gene2,
+            isoform: m.isoform2,
+            strand: m.strand2,
+            chr: m.chr2,
+            position: m.position2
+          }
+        }
+      ]
+    };
+    const n = flag.geneToUpper ? m.gene2.toUpperCase() : m.gene2;
+    if (!flag.data[n]) {
+      flag.data[n] = [];
+    }
+    flag.data[n].push(m2);
+  }
+}
+function duplicate(m) {
+  const n = {};
+  for (const k in m) {
+    if (k == "pairlst") continue;
+    const v = m[k];
+    const type = typeof v;
+    if (type == "object") {
+      continue;
+    }
+    n[k] = v;
+  }
+  if (m.pairlst) {
+    n.pairlst = [];
+    for (const pair of m.pairlst) {
+      const p = {};
+      for (const k in pair) {
+        if (k == "a" || k == "b" || k == "interstitial") {
+          continue;
+        }
+        p[k] = pair[k];
+      }
+      if (pair.a) {
+        p.a = {};
+        for (const k in pair.a) {
+          const v = pair.a[k];
+          if (typeof v == "object") {
+            continue;
+          }
+          p.a[k] = v;
+        }
+      }
+      if (pair.b) {
+        p.b = {};
+        for (const k in pair.b) {
+          const v = pair.b[k];
+          if (typeof v == "object") {
+            continue;
+          }
+          p.b[k] = v;
+        }
+      }
+      if (pair.interstitial) {
+        p.interstitial = {};
+        for (const k in pair.interstitial) {
+          const v = pair.interstitial[k];
+          if (typeof v == "object") {
+            continue;
+          }
+          p.interstitial[k] = v;
+        }
+      }
+      n.pairlst.push(p);
+    }
+  }
+  return n;
+}
+
+export {
+  parseheader,
+  parseline,
+  duplicate
+};
+//# sourceMappingURL=chunk-6UHSGC6G.js.map

package/dist/chunk-6ZZGFZV2.js

@@ -0,0 +1,35 @@
+import {
+  appInit
+} from "./chunk-YBXQBSFY.js";
+import {
+  TermTypes
+} from "./chunk-2N345NXD.js";
+
+// termdb/handlers/ssGSEA.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const genesetDbName = Object.keys(opts.genomeObj.termdbs || {})[0];
+    if (!genesetDbName) throw "genesetDbName missing";
+    await appInit({
+      holder: opts.holder,
+      state: {
+        dslabel: genesetDbName,
+        genome: opts.genomeObj.name,
+        nav: { header_mode: "search_only" }
+      },
+      tree: {
+        click_term: (term) => {
+          this.callback({ id: term.id, type: TermTypes.SSGSEA, name: term.name });
+        }
+      }
+    });
+    opts.holder.select("input.tree_search").attr("data-testid", "sjpp-ssgsea-search");
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-6ZZGFZV2.js.map