@sjcrh/proteinpaint-client 2.207.1 → 2.208.0

package/dist/chunk-BPGZUNLL.js

@@ -0,0 +1,274 @@
+import {
+  termType2label
+} from "./chunk-GMRIEUBW.js";
+import {
+  TermTypes
+} from "./chunk-4EZLVENZ.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-BPGZUNLL.js.map

package/dist/chunk-CPIPN5F6.js

@@ -0,0 +1,141 @@
+import {
+  skipPrevActionAbort,
+  storeInit
+} from "./chunk-MSSPT5YM.js";
+import {
+  recoverInit
+} from "./chunk-X46YA4CB.js";
+import {
+  AppBase,
+  sayerror,
+  vocabInit
+} from "./chunk-QJ3HYZH3.js";
+import {
+  importPlot
+} from "./chunk-DMWOK4DS.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  AppApi
+} from "./chunk-WINIL2KN.js";
+
+// plots/plot.app.ts
+var PlotApp = class _PlotApp extends AppBase {
+  constructor(opts, api) {
+    super(opts);
+    this.components = {};
+    this.wasDestroyed = false;
+    this.api = api;
+    this.type = _PlotApp.type;
+    this.dom = this.getDom(opts);
+  }
+  static {
+    this.type = "app";
+  }
+  getDom(opts) {
+    const dom = {
+      holder: opts.holder,
+      errdiv: opts.holder.append("div"),
+      plotDiv: opts.holder.append("div")
+    };
+    const controls = opts.violin?.mode == "minimal" ? null : opts.holder.append("div").style("white-space", "nowrap");
+    if (controls) {
+      dom.plotControls = controls.append("div").style("display", "inline-block");
+      dom.recoverControls = controls.append("div").style("display", "inline-block");
+    }
+    return dom;
+  }
+  async preApiFreeze(api) {
+    try {
+      api.tip = new Menu({ padding: "5px" });
+      api.printError = (e) => this.printError(e);
+      const vocab = this.opts.state.vocab;
+      api.vocabApi = this.opts.vocabApi ? this.opts.vocabApi : await vocabInit({
+        app: api,
+        state: {
+          vocab: {
+            // either (genome + dslabel) XOR (terms) can be undefined
+            genome: vocab?.genome || this.opts.state.genome,
+            dslabel: vocab?.dslabel || this.opts.state.dslabel,
+            terms: vocab?.terms
+          }
+        },
+        fetchOpts: this.opts.fetchOpts
+      });
+      this.opts.state.vocab = api.vocabApi.vocab;
+    } catch (e) {
+      console.log(`preApiFreeze error`, e);
+      throw e;
+    }
+  }
+  async init() {
+    try {
+      this.opts.state.nav = { header_mode: "hidden" };
+      this.store = await storeInit({ app: this.api, state: this.opts.state });
+      this.state = await this.store.copyState();
+      this.components = {
+        plots: {}
+      };
+      if (this.opts.app?.features?.includes("recover"))
+        this.components.recover = await recoverInit({
+          app: this.api,
+          holder: this.dom.recoverControls,
+          // TODO: ???? may limit the tracked state to only the filter, activeCohort ???
+          getState: (appState) => appState,
+          //reactsTo: action => true, //action.type != 'plot_edit' || action.type == 'app_refresh',
+          maxHistoryLen: 10
+        });
+      if (this.opts.app?.doNotAwaitInitRender) {
+        this.api.dispatch();
+      } else {
+        await this.api.dispatch();
+      }
+    } catch (e) {
+      this.printError(e);
+      throw e;
+    }
+  }
+  async main() {
+    this.api.vocabApi.main();
+    for (const id in this.components.plots) {
+      const plot = this.components.plots[id];
+      if (!this.state.plots.find((p) => p.id === plot.id)) {
+        plot.destroy();
+        delete this.components.plots[id];
+      }
+    }
+    for (const plot of this.state.plots.values()) {
+      if (plot.parentId) continue;
+      if (!this.components.plots[plot.id]) {
+        const holder = this.opts?.app?.getPlotHolder ? this.opts.app.getPlotHolder(plot, this.dom.holder) : this.dom.holder.append("div");
+        if (!this.dom.plotDiv) this.dom.plotDiv = holder;
+        const { componentInit } = await importPlot(plot.chartType);
+        const plotApi = await componentInit({
+          id: plot.id,
+          app: this.api,
+          holder,
+          controls: this.dom.plotControls
+        });
+        this.components.plots[plot.id] = plotApi;
+      }
+    }
+  }
+  printError(e) {
+    sayerror(this.dom.errdiv, "Error: " + (e.message || e));
+    if (e.stack) console.log(e.stack);
+    this.bus.emit("error");
+  }
+  skipPrevActionAbort(action) {
+    return skipPrevActionAbort(action);
+  }
+  destroy() {
+    if (this.dom?.holder) this.dom.holder.selectAll("*").remove();
+  }
+};
+var appInit = AppApi.getInitFxn(PlotApp);
+
+export {
+  appInit
+};
+//# sourceMappingURL=chunk-CPIPN5F6.js.map

package/dist/chunk-D5MSWPAZ.js

@@ -0,0 +1,217 @@
+import {
+  dofetch,
+  dofetch2
+} from "./chunk-VMRO6DMC.js";
+import {
+  contigNameNoChr2
+} from "./chunk-4EZLVENZ.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-D5MSWPAZ.js.map