@sjcrh/proteinpaint-client 2.220.0 → 2.221.0

package/dist/chunk-IJSFSUI4.js

@@ -0,0 +1,302 @@
+import {
+  appear2 as appear,
+  axisstyle,
+  bwSetting,
+  disappear2 as disappear,
+  makeNumericAxisConfig,
+  rgb2hex
+} from "./chunk-WD7FZ5EE.js";
+import {
+  dofetch3
+} from "./chunk-4TJO2DGU.js";
+import {
+  axisLeft
+} from "./chunk-WJLRU5OF.js";
+import {
+  format,
+  linear
+} from "./chunk-4OLM3KSB.js";
+
+// src/block.tk.bigwig.js
+function bigwigfromtemplate(tk, template) {
+  tk.scale = {};
+  if (template.scale) {
+    for (const k in template.scale) {
+      tk.scale[k] = template.scale[k];
+    }
+  } else {
+    tk.scale.auto = 1;
+  }
+  if (tk.normalize) {
+  } else {
+    tk.normalize = {
+      dividefactor: 1,
+      disable: 1
+    };
+  }
+  tk.barheight = template.height || 50;
+  tk.height_main = tk.toppad + tk.barheight + tk.bottompad;
+  if (!tk.ncolor) tk.ncolor = "#BD005E";
+  if (!tk.ncolor2) tk.ncolor2 = "#5E00BD";
+  if (!tk.pcolor) tk.pcolor = "#005EBD";
+  if (!tk.pcolor2) tk.pcolor2 = "#FA7D00";
+}
+function bigwigmaketk(tk, block) {
+  tk.img = tk.glider.append("image");
+  tk.tklabel.attr("y", tk.barheight / 2);
+  tk.leftaxis = tk.gleft.append("g");
+  tk.config_handle = block.maketkconfighandle(tk).on("click", () => {
+    tk.tkconfigtip.clear().showunder(tk.config_handle.node());
+    bigwigconfigpanel(tk, block, tk.tkconfigtip.d, () => bigwigload(tk, block));
+  });
+}
+async function bigwigload(tk, block) {
+  block.tkcloakon(tk);
+  const par = block.tkarg_q(tk);
+  if (tk.dotplotfactor) par.dotplotfactor = tk.dotplotfactor;
+  if (tk.bgcolor) par.bgcolor = tk.bgcolor;
+  tk.height_main = tk.toppad + tk.barheight + tk.bottompad;
+  tk.img.attr("width", block.width).attr("height", tk.barheight);
+  let errtext;
+  try {
+    let data;
+    if (tk.imgData) {
+      data = tk.imgData;
+    } else {
+      data = await dofetch3("tkbigwig", { method: "POST", body: JSON.stringify(par) });
+    }
+    if (data.error) throw data.error;
+    if (!data.src) throw "data.src missing";
+    tk.tklabel.transition().attr("y", tk.barheight / 2);
+    tk.img.attr("xlink:href", data.src);
+    if (data.minv != void 0) {
+      tk.scale.min = data.minv;
+    }
+    if (data.maxv != void 0) {
+      tk.scale.max = data.maxv;
+    }
+    tk.leftaxis.selectAll("*").remove();
+    if (data.nodata) {
+      throw "No data in view range";
+    }
+    const scale = linear().domain([tk.scale.min, tk.scale.max]).range([tk.barheight, 0]);
+    const axis = axisLeft().scale(scale).tickValues([tk.scale.min, tk.scale.max]);
+    if (tk.integer4axis) {
+      axis.tickFormat(format("d"));
+    }
+    axisstyle({
+      axis: tk.leftaxis.call(axis),
+      color: "black",
+      showline: true
+    });
+  } catch (err) {
+    tk.img.attr("width", 0).attr("height", 0);
+    if (err.stack) {
+      console.log(err.stack);
+    }
+    errtext = typeof err == "string" ? err : err.message;
+  } finally {
+    block.tkcloakoff(tk, { error: errtext });
+    block.block_setheight();
+    for (const panel of tk.subpanels) {
+      bigwigloadsubpanel(tk, block, panel);
+    }
+  }
+}
+async function bigwigloadsubpanel(tk, block, panel) {
+  block.tkcloakon_subpanel(panel);
+  const par = block.tkarg_q(tk);
+  if (tk.dotplotfactor) {
+    par.dotplotfactor = tk.dotplotfactor;
+  }
+  par.width = panel.width;
+  par.rglst = [
+    {
+      chr: panel.chr,
+      start: panel.start,
+      stop: panel.stop,
+      width: panel.width
+    }
+  ];
+  delete par.percentile;
+  delete par.autoscale;
+  panel.img.attr("width", panel.width).attr("height", tk.barheight);
+  let errtext;
+  try {
+    if (tk.imgData) throw "subpanel not supported by imgData yet";
+    const data = await dofetch3("tkbigwig", { method: "POST", body: JSON.stringify(par) });
+    if (data.error) throw data.error;
+    panel.img.attr("xlink:href", data.src);
+  } catch (err) {
+    panel.img.attr("width", 0).attr("height", 0);
+    if (err.stack) {
+      console.log(err.stack);
+    }
+    errtext = typeof err == "string" ? err : err.message;
+  } finally {
+    block.tkcloakoff_subpanel(panel, { error: errtext });
+  }
+}
+function bigwigconfigpanel(tk, block, holder, loader) {
+  const config = {
+    pcolor: {},
+    ncolor: {},
+    pcolor2: {},
+    ncolor2: {},
+    // .row
+    // .lab
+    dotplot: {},
+    // .row
+    dividefactor: {}
+  };
+  {
+    const row = holder.append("div").style("margin-bottom", "15px");
+    row.append("span").html("Height  ");
+    row.append("input").attr("size", 5).property("value", tk.barheight).on("keyup", (event) => {
+      if (event.code != "Enter") return;
+      const s = event.target.value;
+      if (s == "") return;
+      const v = Number.parseInt(s);
+      if (Number.isNaN(v) || v <= 1) {
+        alert("track height must be positive integer");
+        return;
+      }
+      tk.barheight = v;
+      loader(bwSetting.height);
+    });
+  }
+  config.pcolor.row = holder.append("div").style("margin-bottom", "15px");
+  config.pcolor.lab = config.pcolor.row.append("span").text("Positive value color").style("padding-right", "10px");
+  config.pcolor.row.append("input").attr("type", "color").property("value", rgb2hex(tk.pcolor)).on("change", (event) => {
+    tk.pcolor = event.target.value;
+    loader(bwSetting.pcolor);
+  });
+  config.ncolor.row = holder.append("div").style("margin-bottom", "15px");
+  config.ncolor.lab = config.ncolor.row.append("span").text("Negative value color").style("padding-right", "10px");
+  config.ncolor.row.append("input").attr("type", "color").property("value", rgb2hex(tk.ncolor)).on("change", (event) => {
+    tk.ncolor = event.target.value;
+    loader(bwSetting.ncolor);
+  });
+  if (!tk.scale.auto) {
+    config.pcolor2.row = holder.append("div").style("margin-bottom", "15px");
+    config.pcolor2.lab = config.pcolor2.row.append("span").html("&ge;Max color").style("padding-right", "10px");
+    config.pcolor2.row.append("input").attr("type", "color").property("value", rgb2hex(tk.pcolor2)).on("change", (event) => {
+      tk.pcolor2 = event.target.value;
+      loader(bwSetting.pcolor2);
+    });
+    config.ncolor2.row = holder.append("div").style("margin-bottom", "15px");
+    config.ncolor2.lab = config.ncolor2.row.append("span").html("&le;Min color").style("padding-right", "10px");
+    config.ncolor2.row.append("input").attr("type", "color").property("value", rgb2hex(tk.ncolor2)).on("change", (event) => {
+      tk.ncolor2 = event.target.value;
+      loader(bwSetting.ncolor2);
+    });
+  }
+  {
+    const setting = {};
+    if (tk.scale.auto) {
+      setting.auto = 1;
+    } else if (tk.scale.percentile) {
+      setting.percentile = tk.scale.percentile;
+    } else {
+      setting.fixed = { min: tk.scale.min, max: tk.scale.max };
+    }
+    makeNumericAxisConfig({
+      holder: holder.append("div").style("margin-bottom", "15px"),
+      setting,
+      callback: (s) => {
+        if (s.auto) {
+          tk.scale.auto = 1;
+          loader(bwSetting.autoscale);
+          return;
+        }
+        if (s.fixed) {
+          delete tk.scale.auto;
+          delete tk.scale.percentile;
+          tk.scale.max = s.fixed.max;
+          tk.scale.min = s.fixed.min;
+          loader(bwSetting.fixedscale);
+          return;
+        }
+        delete tk.scale.auto;
+        tk.scale.percentile = s.percentile;
+        loader(bwSetting.percentilescale);
+      }
+    });
+  }
+  {
+    config.dotplot.row = holder.append("div").style("margin-bottom", "15px");
+    config.dotplot.row.append("span").html("Dot plot&nbsp;&nbsp;");
+    const s = config.dotplot.row.append("select").on("change", (event) => {
+      const i = event.target.selectedIndex;
+      if (i == 0) {
+        delete tk.dotplotfactor;
+      } else {
+        tk.dotplotfactor = Number.parseInt(event.target.options[i].innerHTML);
+      }
+      loader(i == 0 ? bwSetting.nodotplot : bwSetting.usedotplot);
+    });
+    let o = s.append("option").text("no");
+    if (!tk.dotplotfactor) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("5");
+    if (tk.dotplotfactor == 5) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("10");
+    if (tk.dotplotfactor == 10) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("15");
+    if (tk.dotplotfactor == 15) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("20");
+    if (tk.dotplotfactor == 20) {
+      o.property("selected", 1);
+    }
+  }
+  config.dividefactor.row = holder.append("div");
+  {
+    const id = Math.random().toString();
+    const input = config.dividefactor.row.append("input").attr("type", "checkbox").attr("id", id);
+    if (!tk.normalize.disable) {
+      input.property("checked", 1);
+    }
+    config.dividefactor.row.append("label").html("&nbsp;Apply normalization").attr("for", id);
+    const folder = config.dividefactor.row.append("div").style("margin", "5px 10px 0px 20px").style("display", tk.normalize.disable ? "none" : "block");
+    folder.append("span").html("Divide raw value by&nbsp;");
+    const factorinput = folder.append("input").attr("type", "number").style("width", "60px").property("value", tk.normalize.dividefactor).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      const v = event.target.value;
+      if (v <= 0) {
+        return;
+      }
+      tk.normalize.dividefactor = v;
+      loader(bwSetting.usedividefactor);
+    });
+    folder.append("div").text("Enter a value above zero").style("font-size", ".7em").style("color", "#858585");
+    input.on("change", (event) => {
+      if (event.target.checked) {
+        appear(folder);
+        delete tk.normalize.disable;
+        factorinput.property("value", tk.normalize.dividefactor);
+        loader(bwSetting.usedividefactor);
+        return;
+      }
+      disappear(folder);
+      tk.normalize.disable = 1;
+      loader(bwSetting.nodividefactor);
+    });
+  }
+  return config;
+}
+
+export {
+  bigwigfromtemplate,
+  bigwigmaketk,
+  bigwigload,
+  bigwigloadsubpanel,
+  bigwigconfigpanel
+};
+//# sourceMappingURL=chunk-IJSFSUI4.js.map

package/dist/chunk-IRQKX6DL.js

@@ -0,0 +1,263 @@
+import {
+  hierCluster_renderers_exports
+} from "./chunk-GBKQHVKJ.js";
+import {
+  hierCluster_interactivity_exports
+} from "./chunk-WYSOOKFJ.js";
+import {
+  Matrix
+} from "./chunk-AJNFI6GA.js";
+import {
+  filterJoin,
+  getNormalRoot
+} from "./chunk-WD7FZ5EE.js";
+import {
+  clusterMethodLst,
+  distanceMethodLst,
+  dofetch3
+} from "./chunk-4TJO2DGU.js";
+import {
+  TermTypes2Dt,
+  dictionaryNumericTypes
+} from "./chunk-JHLF2ZC2.js";
+import {
+  colorScaleMap
+} from "./chunk-WJLRU5OF.js";
+import {
+  deepEqual,
+  getCompInit
+} from "./chunk-HBNB5TRH.js";
+import {
+  extent,
+  linear
+} from "./chunk-4OLM3KSB.js";
+
+// plots/matrix/hierCluster.js
+var HierCluster = class _HierCluster extends Matrix {
+  static type = "hierCluster";
+  constructor(opts) {
+    super(opts);
+    this.type = _HierCluster.type;
+    this.chartType = _HierCluster.type;
+  }
+  async init(appState) {
+    await super.init(appState);
+    this.maySetSandboxHeader(appState);
+    this.hcClipId = this.seriesClipId + "-hc";
+    this.dom.hcClipRect = this.dom.svg.select("defs").append("clipPath").attr("id", this.hcClipId).attr("clipPathUnits", "userSpaceOnUse").append("rect").attr("display", "block");
+    this.dom.topDendrogram = this.dom.svg.insert("g", "g").attr("clip-path", `url(#${this.hcClipId})`).append("g").attr("class", "sjpp-matrix-dendrogram").attr("data-testid", "hierCluster_top_dendrogram").on("click", (event) => {
+      const clickedClusterId = this.getClusterFromTopDendrogram(event);
+      if (clickedClusterId) {
+        this.clickedClusterIds = this.getAllChildrenClusterIds(clickedClusterId);
+        this.clickedClusterIds.push(clickedClusterId);
+        const clickedCluster = this.hierClusterData.clustering.col.mergedClusters.get(clickedClusterId);
+        const clickedClusterSampleNames = clickedCluster.children.map((c) => c.name);
+        this.addSelectedSamplesOptions(clickedClusterSampleNames, event);
+      } else {
+        delete this.clickedClusterIds;
+      }
+      if (this.clickedLeftClusterIds) {
+        delete this.clickedLeftClusterIds;
+        this.plotDendrogramHclust();
+      } else this.plotDendrogramHclust("top");
+    });
+    this.dom.leftDendrogram = this.dom.svg.insert("g", "g").attr("class", "sjpp-matrix-dendrogram").attr("data-testid", "hierCluster_left_dendrogram").on("click", (event) => {
+      const clickedLeftClusterId = this.getClusterFromLeftDendrogram(event);
+      if (clickedLeftClusterId) {
+        this.clickedLeftClusterIds = this.getAllChildrenClusterIds(clickedLeftClusterId, true);
+        this.clickedLeftClusterIds.push(clickedLeftClusterId);
+        const clickedLeftCluster = this.hierClusterData.clustering.row.mergedClusters.get(clickedLeftClusterId);
+        const clickedLeftClusterRowsNames = clickedLeftCluster.children.map((c) => c.name);
+        this.addSelectedRowsOptions(clickedLeftClusterRowsNames, event);
+      } else {
+        delete this.clickedLeftClusterIds;
+      }
+      if (this.clickedClusterIds) {
+        delete this.clickedClusterIds;
+        this.plotDendrogramHclust();
+      } else this.plotDendrogramHclust("left");
+    });
+  }
+  async setHierClusterData(_data = {}) {
+    this.prevServerData = this.currServerData;
+    const [d, twlst] = await this.requestData({});
+    if (d.error) throw d.error;
+    this.currServerData = structuredClone(d);
+    if (!deepEqual(this.prevServerData, this.currServerData)) {
+      delete this.clickedClusterIds;
+      delete this.clickedLeftClusterIds;
+    }
+    const s = this.settings.hierCluster;
+    if (!d.clustering) {
+      if (d.gene) {
+        throw `Cannot do clustering: data is only available for 1 gene (${d.gene}). Try again by adding more genes.`;
+      }
+    }
+    this.hierClusterData = d;
+    const c = this.hierClusterData.clustering;
+    this.setHierColorScale(c);
+    const samples = {};
+    for (const [i, column] of c.col.order.entries()) {
+      samples[column.name] = { sample: column.name };
+      for (const [j, row] of c.row.order.entries()) {
+        const tw = twlst.find((tw2) => tw2.$id === row.name || tw2.id === row.name);
+        const value = c.matrix[j][i];
+        samples[column.name][tw.$id] = {
+          key: tw.term.name,
+          values: [
+            {
+              sample: column.name,
+              dt: TermTypes2Dt[this.state.config.dataType],
+              label: s.termGroupName,
+              // gene: tw.term.name,
+              // chr: tw.term.chr,
+              // pos: `${tw.term.start}-${tw.term.stop}`,
+              value
+              // the color will be computed in matrix.cells, so that
+              // it can get updated even when there are no nonsetting state diff
+            }
+          ]
+        };
+      }
+    }
+    this.hcTermNameOrder = this.settings.hierCluster.sortClusterRows == "asListed" ? twlst.map((t) => t.term.name) : this.settings.hierCluster.sortClusterRows == "byName" ? twlst.map((t) => t.term.name).sort() : dictionaryNumericTypes.has(this.config.dataType) ? c.row.order.map((row) => twlst.find((t) => t.$id == row.name || t.term.id == row.name)?.term.name) : c.row.order.map((row) => twlst.find((t) => t.$id == row.name)?.term.name);
+    if (this.hcTermNameOrder.includes(void 0)) throw `unable to map row.name to term.name`;
+    this.hcTermSorter = (a, b) => {
+      const i = this.hcTermNameOrder.indexOf(a.tw.term.name);
+      const j = this.hcTermNameOrder.indexOf(b.tw.term.name);
+      if (i == -1 && j == -1) return 0;
+      if (i == -1) return 1;
+      if (j == -1) return -1;
+      return i - j;
+    };
+    this.hcSampleNameOrder = c.col.order.map((col) => col.name);
+    this.hcSampleSorter = (a, b) => {
+      const i = this.hcSampleNameOrder.indexOf(a.sample);
+      const j = this.hcSampleNameOrder.indexOf(b.sample);
+      if (i == -1 && j == -1) return 0;
+      if (i == -1) return 1;
+      if (j == -1) return -1;
+      return i - j;
+    };
+    const byTermId = {};
+    for (const tw of twlst) {
+      if (d.byTermId?.[tw.term.name]) byTermId[tw.$id] = d.byTermId[tw.term.name];
+    }
+    this.hierClusterSamples = {
+      refs: { byTermId, bySampleId: d.bySampleId },
+      lst: c.col.order.map((c2) => samples[c2.name]),
+      samples,
+      removedHierClusterTerms: d.removedHierClusterTerms
+    };
+  }
+  async requestData() {
+    const body = this.currRequestOpts?.hierCluster || this.getHCRequestBody(this.state);
+    const twlst = this.hcTermGroup.lst;
+    const data = await dofetch3("termdb/cluster", { body, signal: this.api.getAbortSignal?.() });
+    return [data, twlst];
+  }
+  getHCRequestBody(state) {
+    this.hcTermGroup = this.config.termgroups.find((grp) => grp.type == "hierCluster") || this.termOrder?.find((t) => t.grp.type == "hierCluster")?.grp;
+    const s = state.config.settings.hierCluster;
+    const dictionaryLegendFilter = {
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: state.config.legendValueFilter.lst.filter((f) => !f.tvs.legendFilterType)
+    };
+    const terms = this.getClusterRowTermsAsParameter();
+    if (!terms.length) throw "no data";
+    if (!clusterMethodLst.find((i) => i.value == s.clusterMethod)) throw "Invalid cluster method";
+    if (!distanceMethodLst.find((i) => i.value == s.distanceMethod)) throw "Invalid distance method";
+    const body = {
+      genome: state.vocab.genome,
+      dslabel: state.vocab.dslabel,
+      dataType: state.config.dataType,
+      clusterMethod: s.clusterMethod,
+      distanceMethod: s.distanceMethod,
+      zScoreTransformation: s.zScoreTransformation,
+      terms,
+      filter: getNormalRoot(filterJoin([state.filter, dictionaryLegendFilter])),
+      filter0: state.filter0
+    };
+    if (state.config.dataType == "proteomeAbundance") {
+      body.proteomeDetails = {
+        organism: state.config.proteomeDetails?.organism,
+        assay: state.config.proteomeDetails?.assay,
+        cohort: state.config.proteomeDetails?.cohort
+      };
+    }
+    return body;
+  }
+  combineData() {
+    if (!this.hierClusterSamples) return;
+    const d = this.data;
+    const removedHierClusterTerms = this.hierClusterSamples.removedHierClusterTerms;
+    const samples = {};
+    const lst = [];
+    for (const sampleId in this.hierClusterSamples.samples) {
+      const s = this.hierClusterSamples.samples[sampleId];
+      samples[sampleId] = s;
+      lst.push(s);
+      if (sampleId in d.samples) Object.assign(s, d.samples[sampleId]);
+      const _ref_ = this.hierClusterSamples.refs.bySampleId[sampleId] || {};
+      if (!s._ref_) s._ref_ = _ref_;
+      else Object.assign(s._ref_, _ref_);
+    }
+    const t = this.hierClusterSamples.refs.byTermId;
+    for (const $id of Object.keys(t)) {
+      d.refs.byTermId[$id] = Object.assign({}, d.refs.byTermId[$id] || {}, t[$id]);
+    }
+    this.data = { samples, lst, refs: d.refs, removedHierClusterTerms };
+  }
+  setHierColorScale(c) {
+    const hc = this.settings.hierCluster;
+    const scale = linear(colorScaleMap[hc.colorScale].domain, colorScaleMap[hc.colorScale].range).clamp(true);
+    const globalMinMaxes = [];
+    for (const row of c.matrix) {
+      globalMinMaxes.push(...extent(row));
+    }
+    const absMax = Math.min(hc.zScoreCap, Math.max(...extent(globalMinMaxes).map(Math.abs)));
+    const [min, max] = hc.zScoreTransformation ? [-absMax, absMax] : [Math.min(...globalMinMaxes), Math.max(...globalMinMaxes)];
+    this.hierClusterValues = { scale, min, max };
+  }
+  getValueColor(value) {
+    const hc = this.settings.hierCluster;
+    if (hc.zScoreTransformation) {
+      const zScoreCap = this.settings.hierCluster.zScoreCap;
+      return this.hierClusterValues.scale((value - -zScoreCap) / (zScoreCap * 2));
+    } else {
+      return this.hierClusterValues.scale(value / this.hierClusterValues.max);
+    }
+  }
+  /* returns list of gene terms as request parameter, e.g. {gene,chr,start,stop}
+  	request parameter only need term but not tw, as it will simply fetch continuous sample values on terms without transform
+  
+  	use of this function is unfortunate because:
+  		the incomplete migration of {name} to {gene} for gene-based term
+  		geneset edit ui is hardcoded to return {name}
+  		existing plot states contain {name}
+  
+  	!!! migration instruction !!!
+  	- term.name is for display only, if a term is gene-based, it has term.gene=str
+  	- a geneVariant term can be based on a genomic range (and not a gene), in that case it won't have term.gene and cannot be used where gene is expected, e.g. gene-based clustering analysis
+  
+  	*/
+  getClusterRowTermsAsParameter() {
+    const lst = this.hcTermGroup.lst.map(this.opts.app.vocabApi.getTwMinCopy);
+    lst.sort((a, b) => a.term.name < b.term.name ? -1 : 1);
+    return lst;
+  }
+};
+for (const methods of [hierCluster_renderers_exports, hierCluster_interactivity_exports]) {
+  for (const methodName in methods) HierCluster.prototype[methodName] = methods[methodName];
+}
+var hierClusterInit = getCompInit(HierCluster);
+var componentInit = hierClusterInit;
+
+export {
+  HierCluster,
+  hierClusterInit,
+  componentInit
+};
+//# sourceMappingURL=chunk-IRQKX6DL.js.map