@sjcrh/proteinpaint-client 2.224.1 → 2.224.2

package/dist/chunk-F6CYUMSM.js

@@ -0,0 +1,37 @@
+import {
+  DMR_SCAN_ELEMENT_TYPE
+} from "./chunk-R2H22S4J.js";
+
+// plots/gsea/settings/defaults.ts
+function isDmrScanRanking(opts) {
+  return opts?.elementType === DMR_SCAN_ELEMENT_TYPE || opts?.gsea_params?.daRequest?.element_type === DMR_SCAN_ELEMENT_TYPE;
+}
+function getDefaultGseaSettings(overrides = {}, opts = {}) {
+  const defaults = {
+    fdr_cutoff: 0.05,
+    num_permutations: 1e3,
+    top_genesets: 40,
+    pathway: opts?.gsea_params?.pathway ?? void 0,
+    geneset_name: null,
+    min_gene_set_size_cutoff: 0,
+    /* 500 only for a DMR scan's gene-body ranking, where blitzgsea's null fit is unstable above it.
+    The server enforces that ceiling on the library before the fit (genesetEnrichment.ts); this
+    default only keeps the table's own size filter consistent with it, and daRequest may not be
+    known yet when defaults are first built. Every other caller keeps 20,000, because lowering it
+    for them would silently drop large GO and Reactome sets from analyses that have always shown
+    them. */
+    max_gene_set_size_cutoff: isDmrScanRanking(opts) ? 500 : 2e4,
+    filter_non_coding_genes: true,
+    fdr_or_top: "top",
+    gsea_method: "blitzgsea"
+  };
+  if (JSON.parse(sessionStorage.getItem("optionalFeatures") || "{}")?.gsea_test) {
+    defaults.gsea_method = "cerno";
+  }
+  return Object.assign(defaults, overrides);
+}
+
+export {
+  getDefaultGseaSettings
+};
+//# sourceMappingURL=chunk-F6CYUMSM.js.map

package/dist/chunk-FUTHP5J4.js

@@ -0,0 +1,274 @@
+import {
+  termType2label
+} from "./chunk-5FD6NRGE.js";
+import {
+  TermTypes
+} from "./chunk-R2H22S4J.js";
+import {
+  __export
+} from "./chunk-HS5PO5ZQ.js";
+
+// plots/matrix/hierCluster.renderers.js
+var hierCluster_renderers_exports = {};
+__export(hierCluster_renderers_exports, {
+  maySetSandboxHeader: () => maySetSandboxHeader,
+  plotDendrogramHclust: () => plotDendrogramHclust,
+  renderImage: () => renderImage
+});
+function maySetSandboxHeader(appState) {
+  if (!this.dom.header) return;
+  const dataType = this.config.dataType;
+  const headerText = this.config?.headerText ? `${this.config.headerText} ` : "";
+  let title;
+  if (this.config.preBuiltPlotTitle) {
+    title = this.config.preBuiltPlotTitle;
+  } else if (this.config.appName) {
+    title = `${headerText}${this.config.appName} Clustering`;
+  } else if (dataType == TermTypes.PROTEOME_ABUNDANCE) {
+    title = this.config.assayCohortTitle ? `Protein Abundance Clustering (${this.config.assayCohortTitle})` : "Protein Abundance Clustering";
+  } else {
+    title = `${headerText}${termType2label(dataType)} Clustering`;
+  }
+  this.dom.header.text(title);
+}
+function plotDendrogramHclust(plotOnly) {
+  const d = this.dimensions;
+  const s = this.config.settings.matrix;
+  const xOffset = d.seriesXoffset;
+  const pxr = window.devicePixelRatio <= 1 ? 1 : window.devicePixelRatio;
+  const obj = this.hierClusterData.clustering;
+  const row = obj.row;
+  const col = obj.col;
+  const rowHeight = this.settings.matrix.clusterRowh, { xDendrogramHeight, yDendrogramHeight } = this.settings.hierCluster, colWidth = this.dimensions.dx;
+  if (plotOnly !== "left") {
+    if (!this.settings.hierCluster.clusterSamples) {
+      this.dom.topDendrogram.selectAll("*").remove();
+    } else {
+      const height2px = getHclustHeightScalefactor(col.height, yDendrogramHeight);
+      const height = yDendrogramHeight + 1e-7;
+      const width = Math.min(colWidth * col.inputOrder.length, s.imgWMax);
+      if (width <= 0 || height <= 0) {
+        console.warn(
+          "Skipping top dendrogram render: invalid dimensions.",
+          "This may indicate a zoom feedback loop issue.",
+          {
+            width,
+            height,
+            colWidth,
+            sampleCount: col.inputOrder.length,
+            yDendrogramHeight
+          }
+        );
+        this.dom.topDendrogram.selectAll("*").remove();
+        return;
+      }
+      const canvas = new OffscreenCanvas(width * pxr, height * pxr);
+      const ctx = canvas.getContext("2d");
+      ctx.scale(pxr, pxr);
+      ctx.translate(-d.xMin, 0);
+      ctx.imageSmoothingEnabled = false;
+      ctx.imageSmoothingQuality = "high";
+      ctx.strokeStyle = "black";
+      const mergedClusters = /* @__PURE__ */ new Map();
+      for (const [clusterid0, pair] of col.merge.entries()) {
+        const clusterid = clusterid0 + 1;
+        const children = [];
+        const childrenClusters = [];
+        let x1, x2, y1, y2;
+        if (pair.n1 < 0) {
+          const [name, columnNumber] = getLeafNumber(pair.n1, col.inputOrder, col.order);
+          x1 = colWidth * (columnNumber + 0.5);
+          y1 = yDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n1)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n1);
+          x1 = c.x;
+          y1 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n1);
+        }
+        if (pair.n2 < 0) {
+          const [name, columnNumber] = getLeafNumber(pair.n2, col.inputOrder, col.order);
+          x2 = colWidth * (columnNumber + 0.5);
+          y2 = yDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n2)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n2);
+          x2 = c.x;
+          y2 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n2);
+        }
+        const clusterY = yDendrogramHeight - col.height[clusterid0].height * height2px;
+        const highlight = this.clickedClusterIds?.includes(clusterid);
+        ctx.strokeStyle = highlight ? "red" : "black";
+        ctx.beginPath();
+        ctx.moveTo(x1, y1);
+        ctx.lineTo(x1, clusterY);
+        ctx.lineTo(x2, clusterY);
+        ctx.lineTo(x2, y2);
+        ctx.stroke();
+        ctx.closePath();
+        mergedClusters.set(clusterid, {
+          x: (x1 + x2) / 2,
+          y: clusterY,
+          children,
+          childrenClusters,
+          clusterPosition: {
+            x1,
+            x2,
+            y1,
+            y2,
+            clusterY
+          }
+        });
+      }
+      this.renderImage(
+        this.api,
+        this.dom.topDendrogram,
+        canvas,
+        width,
+        height,
+        xDendrogramHeight + 0.5 * colWidth + d.xMin,
+        s.margin.top + s.scrollHeight
+      );
+      col.mergedClusters = mergedClusters;
+    }
+  }
+  if (plotOnly !== "top") {
+    if (!this.settings.hierCluster.clusterRows) {
+      this.dom.leftDendrogram.selectAll("*").remove();
+    } else {
+      const height2px = getHclustHeightScalefactor(row.height, xDendrogramHeight);
+      const width = xDendrogramHeight + 1e-7;
+      const height = rowHeight * row.inputOrder.length;
+      const canvasWidthPx = Number.isFinite(width) && Number.isFinite(pxr) ? Math.max(0, Math.floor(width * pxr)) : 0;
+      const canvasHeightPx = Number.isFinite(height) && Number.isFinite(pxr) ? Math.max(0, Math.floor(height * pxr)) : 0;
+      if (!Number.isFinite(width) || !Number.isFinite(height) || !Number.isFinite(pxr) || width <= 0 || height <= 0 || pxr <= 0 || canvasWidthPx < 1 || canvasHeightPx < 1) {
+        console.warn(
+          "Skipping left dendrogram render: invalid dimensions.",
+          "This may indicate a zoom feedback loop issue.",
+          {
+            width,
+            height,
+            pxr,
+            canvasWidthPx,
+            canvasHeightPx,
+            rowHeight,
+            termCount: row.inputOrder.length,
+            xDendrogramHeight
+          }
+        );
+        this.dom.leftDendrogram.selectAll("*").remove();
+        return;
+      }
+      const canvas = new OffscreenCanvas(canvasWidthPx, canvasHeightPx);
+      const ctx = canvas.getContext("2d");
+      ctx.scale(pxr, pxr);
+      ctx.imageSmoothingEnabled = false;
+      ctx.imageSmoothingQuality = "high";
+      ctx.strokeStyle = "black";
+      const mergedClusters = /* @__PURE__ */ new Map();
+      for (const [clusterid0, pair] of row.merge.entries()) {
+        const clusterid = clusterid0 + 1;
+        const children = [];
+        const childrenClusters = [];
+        let x1, x2, y1, y2;
+        if (pair.n1 < 0) {
+          const [name, rowNumber] = getLeafNumber(pair.n1, row.inputOrder, row.order);
+          y1 = rowHeight * (rowNumber + 0.5);
+          x1 = xDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n1)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n1);
+          x1 = c.x;
+          y1 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n1);
+        }
+        if (pair.n2 < 0) {
+          const [name, rowNumber] = getLeafNumber(pair.n2, row.inputOrder, row.order);
+          y2 = rowHeight * (rowNumber + 0.5);
+          x2 = xDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n2)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n2);
+          x2 = c.x;
+          y2 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n2);
+        }
+        const clusterX = xDendrogramHeight - row.height[clusterid0].height * height2px;
+        const highlight = this.clickedLeftClusterIds?.includes(clusterid);
+        ctx.strokeStyle = highlight ? "red" : "black";
+        ctx.beginPath();
+        ctx.moveTo(x1, y1);
+        ctx.lineTo(clusterX, y1);
+        ctx.lineTo(clusterX, y2);
+        ctx.lineTo(x2, y2);
+        ctx.stroke();
+        ctx.closePath();
+        mergedClusters.set(clusterid, {
+          x: clusterX,
+          y: (y1 + y2) / 2,
+          children,
+          childrenClusters,
+          clusterPosition: {
+            x1,
+            x2,
+            y1,
+            y2,
+            clusterX
+          }
+        });
+      }
+      const t = this.termOrder.find((t2) => t2.grp.type == "hierCluster" || t2.grp.name == this.hcTermGroup.name);
+      const y = (
+        // t.labelOffset is commented out because it is already handled in adjustSvgDimensions
+        t.grpIndex * s.rowgspace + t.prevGrpTotalIndex * s.rowh + t.totalHtAdjustments + s.margin.top + s.scrollHeight + // left dendrogram image must be lower than the top dendrogram image height
+        yDendrogramHeight
+      );
+      this.renderImage(this.api, this.dom.leftDendrogram, canvas, width, height, 0, y);
+      row.mergedClusters = mergedClusters;
+    }
+  }
+}
+async function renderImage(componentApi, g, canvas, width, height, x, y) {
+  const sequenceId = componentApi.getSequenceId();
+  const reader = new FileReader();
+  reader.addEventListener(
+    "load",
+    () => {
+      if (componentApi.isStaleSequenceId(sequenceId)) return;
+      g.selectAll("*").remove();
+      g.append("image").attr("x", x + 0.033).attr("y", y + 0.033).attr("xlink:href", reader.result).attr("width", width).attr("height", height);
+    },
+    false
+  );
+  const blob = await canvas.convertToBlob({ quality: 1 });
+  reader.readAsDataURL(blob);
+}
+function getHclustHeightScalefactor(lst, ph) {
+  let max = lst[0].height;
+  for (const h of lst) max = Math.max(max, h.height);
+  return ph / max;
+}
+function getLeafNumber(minus, inputOrder, order) {
+  const name = inputOrder[-minus - 1];
+  if (!name) throw "minus not in inputOrder";
+  const i = order.findIndex((j) => j.name == name);
+  if (i == -1) throw "name not found in hc$order";
+  return [name, i];
+}
+
+export {
+  maySetSandboxHeader,
+  plotDendrogramHclust,
+  renderImage,
+  hierCluster_renderers_exports
+};
+//# sourceMappingURL=chunk-FUTHP5J4.js.map

package/dist/chunk-G5GFCBJT.js

@@ -0,0 +1,217 @@
+import {
+  dofetch,
+  dofetch2
+} from "./chunk-ZUXXBQ7D.js";
+import {
+  contigNameNoChr2
+} from "./chunk-R2H22S4J.js";
+
+// tracks/hic/data/parseData.ts
+async function hicParseFile(hic, debugmode, errList = []) {
+  if (debugmode) window["hic"] = hic;
+  if (hic.tklst) {
+    const lst = [];
+    for (const t of hic.tklst) {
+      if (!t.type) {
+        errList.push("type missing from one of the tracks accompanying HiC");
+      } else {
+        t.iscustom = true;
+        lst.push(t);
+      }
+    }
+    if (lst.length) {
+      hic.tklst = lst;
+    } else {
+      delete hic.tklst;
+    }
+  }
+  if (hic.enzyme) {
+    if (hic.genome.hicenzymefragment) {
+      let frag = null;
+      for (const f of hic.genome.hicenzymefragment) {
+        if (f.enzyme == hic.enzyme) {
+          frag = f;
+          break;
+        }
+      }
+      if (frag) {
+        hic.enzymefile = frag.file;
+      } else {
+        errList.push("unknown enzyme: " + hic.enzyme);
+        delete hic.enzyme;
+      }
+    } else {
+      errList.push("no enzyme fragment information available for this genome");
+      delete hic.enzyme;
+    }
+  }
+  try {
+    if (hic.sv && hic.sv.file) {
+      const re = await dofetch(hic.hostURL + "/textfile", {
+        method: "POST",
+        body: JSON.stringify({ file: hic.sv.file, jwt: hic.jwt })
+      });
+      const data2 = re.json();
+      const [err2, header, items] = parseSV(data2.text);
+      if (err2) throw { message: "Error parsing SV: " + err2 };
+      hic.sv.header = header;
+      hic.sv.items = items;
+    }
+    const data = await dofetch2("hicstat?" + (hic.file ? "file=" + hic.file : "url=" + hic.url));
+    if (data.error) {
+      errList.push(data.error);
+      return;
+    }
+    const err = hicparsestat(hic, data.out);
+    if (err) throw { message: err };
+  } catch (err) {
+    errList.push(err.message || err);
+    if (err.stack) {
+      console.log(err.stack);
+    }
+  }
+  return hic;
+}
+function parseSV(txt) {
+  const lines = txt.trim().split(/\r?\n/);
+  const [err, header] = parseSVheader(lines[0]);
+  if (err) return ["header error: " + err];
+  const items = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line[0] == "#") continue;
+    const [e, m] = parseSVline(line, header);
+    if (e) return ["line " + (i + 1) + " error: " + e];
+    items.push(m);
+  }
+  return [null, header, items];
+}
+function parseSVheader(line) {
+  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("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("strand_a", "orta", "orienta");
+  if (i == -1) return "strand_a missing from header";
+  header[i] = "strand1";
+  i = htry("strand_b", "ortb", "orientb");
+  if (i == -1) return "strand_b missing from header";
+  header[i] = "strand2";
+  i = htry("numreadsa");
+  if (i != -1) header[i] = "reads1";
+  i = htry("numreadsb");
+  if (i != -1) header[i] = "reads2";
+  return [null, header];
+}
+function parseSVline(line, header) {
+  const lst = line.split("	");
+  const m = {};
+  for (let j = 0; j < header.length; j++) {
+    m[header[j]] = lst[j];
+  }
+  if (!m.chr1) return ["missing chr1"];
+  if (m.chr1.toLowerCase().indexOf("chr") != 0) {
+    m.chr1 = "chr" + m.chr1;
+  }
+  if (!m.chr2) return ["missing chr2"];
+  if (m.chr2.toLowerCase().indexOf("chr") != 0) {
+    m.chr2 = "chr" + m.chr2;
+  }
+  if (!m.position1) return ["missing position1"];
+  let v = Number.parseInt(m.position1);
+  if (Number.isNaN(v) || v <= 0) return ["position1 invalid value"];
+  m.position1 = v;
+  if (!m.position2) return ["missing position2"];
+  v = Number.parseInt(m.position2);
+  if (Number.isNaN(v) || v <= 0) return ["position2 invalid value"];
+  m.position2 = v;
+  if (m.reads1) {
+    v = Number.parseInt(m.reads1);
+    if (Number.isNaN(v)) return ["reads1 invalid value"];
+    m.reads1 = v;
+  }
+  if (m.reads2) {
+    v = Number.parseInt(m.reads2);
+    if (Number.isNaN(v)) return ["reads2 invalid value"];
+    m.reads2 = v;
+  }
+  return [null, m];
+}
+function hicparsestat(hic, j) {
+  if (!j) return "cannot stat hic file";
+  hic.normalization = j.normalization;
+  hic.version = j.version;
+  if (!j.Chromosomes) return "Chromosomes not found in file stat";
+  if (!Array.isArray(j.chrorder)) return ".chrorder[] missing";
+  if (j.chrorder.length == 0) return ".chrorder[] empty array";
+  hic.chrorder = j.chrorder;
+  if (!j["Base pair-delimited resolutions"]) return "Base pair-delimited resolutions not found in file stat";
+  if (!Array.isArray(j["Base pair-delimited resolutions"])) return "Base pair-delimited resolutions should be array";
+  hic.bpresolution = j["Base pair-delimited resolutions"];
+  if (!j["Fragment-delimited resolutions"]) return "Fragment-delimited resolutions not found in file stat";
+  if (!Array.isArray(j["Fragment-delimited resolutions"])) return "Fragment-delimited resolutions is not array";
+  hic.fragresolution = j["Fragment-delimited resolutions"];
+  const chrlst = [];
+  for (const chr in j.Chromosomes) {
+    chrlst.push(chr);
+  }
+  const [nochrcount, haschrcount] = contigNameNoChr2(hic.genome, chrlst);
+  if (nochrcount + haschrcount == 0) return "chromosome names do not match with genome build";
+  if (nochrcount > 0) {
+    hic.nochr = true;
+    for (let i = 0; i < hic.chrorder.length; i++) hic.chrorder[i] = "chr" + hic.chrorder[i];
+  }
+  hic.chrlst = [];
+  for (const chr of hic.genome.majorchrorder) {
+    const c2 = hic.nochr ? chr.replace("chr", "") : chr;
+    if (chrlst.indexOf(c2) != -1) {
+      hic.chrlst.push(chr);
+    }
+  }
+}
+function hicparsefragdata(items) {
+  const id2coord = /* @__PURE__ */ new Map();
+  let min = null, max;
+  for (const i of items) {
+    if (!i.rest || !i.rest[0]) {
+      return ["items[].rest data problem"];
+    }
+    const id = Number.parseInt(i.rest[0]);
+    if (Number.isNaN(id)) {
+      return [i.start + "." + i.stop + " invalid fragment id: " + i.rest[0]];
+    }
+    id2coord.set(id, [i.start, i.stop]);
+    if (min == null) {
+      min = id;
+      max = id;
+    } else {
+      min = Math.min(min, id);
+      max = Math.max(max, id);
+    }
+  }
+  return [null, id2coord, min, max];
+}
+
+export {
+  hicParseFile,
+  hicparsestat,
+  hicparsefragdata
+};
+//# sourceMappingURL=chunk-G5GFCBJT.js.map

package/dist/chunk-GOL6A746.js

@@ -0,0 +1,96 @@
+import {
+  keyupEnter,
+  require_debounce
+} from "./chunk-ZIMAIUZD.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import {
+  dofetch,
+  dofetch3
+} from "./chunk-ZUXXBQ7D.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// src/gene.js
+var import_debounce = __toESM(require_debounce(), 1);
+var tip;
+function gene_searchbox(p) {
+  if (!tip) {
+    tip = new Menu({ padding: "" });
+    tip.d.style("z-index", 1e3);
+  }
+  const input = p.div.append("input").attr("placeholder", "Search gene").style("width", p.width || "100px");
+  const printdiv = p.resultdiv || (p.tip ? p.tip.d : tip.d);
+  function fold() {
+    if (p.resultdiv) {
+      p.resultdiv.selectAll("*").remove();
+    } else if (p.tip) {
+      p.tip.hide();
+    } else {
+      tip.hide();
+    }
+  }
+  input.on("keyup", (event) => {
+    const str = event.target.value;
+    if (str.length <= 1) {
+      fold();
+      return;
+    }
+    if (keyupEnter(event)) {
+      const hitgene = printdiv.select(".sja_menuoption");
+      if (hitgene.size() > 0) {
+        p.callback(hitgene.text());
+        fold();
+      }
+      return;
+    }
+    debouncer();
+  });
+  input.node().focus();
+  function genesearch() {
+    dofetch("genelookup", { genome: p.genome, input: input.property("value") }).then((data) => {
+      if (data.error) throw data.error;
+      if (!data.hits) throw ".hits[] missing";
+      if (p.resultdiv) {
+        p.resultdiv.selectAll("*").remove();
+      } else if (p.tip) {
+        p.tip.clear().showunder(input.node());
+      } else {
+        tip.clear().showunder(input.node());
+      }
+      for (const name of data.hits) {
+        printdiv.append("div").attr("class", "sja_menuoption").text(name).on("click", () => {
+          p.callback(name);
+          fold();
+        });
+      }
+    }).catch((err) => {
+      printdiv.append("div").text(err.message || err);
+      if (err.stack) console.log(err.stack);
+    });
+  }
+  const debouncer = (0, import_debounce.debounce)(genesearch, 300);
+}
+function findgenemodel_bysymbol(genome, str) {
+  return dofetch3("genelookup", {
+    body: {
+      deep: 1,
+      input: str,
+      genome
+    }
+  }).then((data) => {
+    if (data.error) throw data.error;
+    if (!data.gmlst || data.gmlst.length == 0) return null;
+    return data.gmlst;
+  }).catch((e) => {
+    throw e;
+  });
+}
+
+export {
+  gene_searchbox,
+  findgenemodel_bysymbol
+};
+//# sourceMappingURL=chunk-GOL6A746.js.map