@sjcrh/proteinpaint-client 2.222.0 → 2.224.0

package/dist/chunk-KLNERWVR.js

@@ -0,0 +1,263 @@
+import {
+  hierCluster_interactivity_exports
+} from "./chunk-LOCZDGJO.js";
+import {
+  Matrix
+} from "./chunk-LE2GFNOI.js";
+import {
+  hierCluster_renderers_exports
+} from "./chunk-GBKQHVKJ.js";
+import {
+  filterJoin,
+  getNormalRoot
+} from "./chunk-U45YALDI.js";
+import {
+  clusterMethodLst,
+  distanceMethodLst,
+  dofetch3
+} from "./chunk-KBTFT76L.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-KLNERWVR.js.map

package/dist/chunk-KZXFNO75.js

@@ -0,0 +1,184 @@
+import {
+  __glob
+} from "./chunk-HS5PO5ZQ.js";
+
+// import("../plots/**/*.js") in plots/importPlot.js
+var globImport_plots_js = __glob({
+  "../plots/controls.btns.js": () => import("./controls.btns-6AKLIWOG.js"),
+  "../plots/controls.config.js": () => import("./controls.config-353QCQTZ.js"),
+  "../plots/controls.js": () => import("./controls-Z4URI2HB.js"),
+  "../plots/dictionary.js": () => import("./dictionary-S4MSWVZV.js"),
+  "../plots/gb/test/genomeBrowser.spec.js": () => import("./genomeBrowser.spec-6YCQISMJ.js"),
+  "../plots/geneExpression.js": () => import("./geneExpression-6JNMJMWW.js"),
+  "../plots/geneORA.js": () => import("./geneORA-NWJCROO7.js"),
+  "../plots/geneset.js": () => import("./geneset-UODQ45RY.js"),
+  "../plots/hierCluster.js": () => import("./hierCluster-W5GMLGYX.js"),
+  "../plots/importPlot.js": () => import("./importPlot-CEK76RBM.js"),
+  "../plots/matrix.js": () => import("./matrix-KWYUKXMK.js"),
+  "../plots/matrix/hierCluster.config.js": () => import("./hierCluster.config-R5TSOJXJ.js"),
+  "../plots/matrix/hierCluster.interactivity.js": () => import("./hierCluster.interactivity-5EFMAIWI.js"),
+  "../plots/matrix/hierCluster.js": () => import("./hierCluster-36UVKTYM.js"),
+  "../plots/matrix/hierCluster.renderers.js": () => import("./hierCluster.renderers-YGX6MZZW.js"),
+  "../plots/matrix/matrix.cells.js": () => import("./matrix.cells-5RTZUJVN.js"),
+  "../plots/matrix/matrix.cluster.js": () => import("./matrix.cluster-RH4BOM5F.js"),
+  "../plots/matrix/matrix.config.js": () => import("./matrix.config-RO3SVOXR.js"),
+  "../plots/matrix/matrix.data.js": () => import("./matrix.data-Y5TPRGMW.js"),
+  "../plots/matrix/matrix.dom.js": () => import("./matrix.dom-Q5XSAUUH.js"),
+  "../plots/matrix/matrix.groups.js": () => import("./matrix.groups-6DXCAY4P.js"),
+  "../plots/matrix/matrix.interactivity.js": () => import("./matrix.interactivity-IFAZAA5Z.js"),
+  "../plots/matrix/matrix.js": () => import("./matrix-TFFEEDIA.js"),
+  "../plots/matrix/matrix.layout.js": () => import("./matrix.layout-YBOMANSO.js"),
+  "../plots/matrix/matrix.legend.js": () => import("./matrix.legend-S3E76TVO.js"),
+  "../plots/matrix/matrix.renderers.js": () => import("./matrix.renderers-GMFIA6FN.js"),
+  "../plots/matrix/matrix.serieses.js": () => import("./matrix.serieses-3UGLZW25.js"),
+  "../plots/matrix/matrix.sort.js": () => import("./matrix.sort-A7CNLDUJ.js"),
+  "../plots/matrix/matrix.sorterUi.js": () => import("./matrix.sorterUi-6PZR3YOD.js"),
+  "../plots/matrix/test/hierCluster.integration.spec.js": () => import("./hierCluster.integration.spec-DWKVGISB.js"),
+  "../plots/matrix/test/matrix.integration.spec.js": () => import("./matrix.integration.spec-SVRHEE3X.js"),
+  "../plots/matrix/test/matrix.sort.unit.spec.js": () => import("./matrix.sort.unit.spec-OTC5SKDW.js"),
+  "../plots/matrix/test/matrix.sorterUi.unit.spec.js": () => import("./matrix.sorterUi.unit.spec-2AJSZUK3.js"),
+  "../plots/matrix/test/matrix.unit.spec.js": () => import("./matrix.unit.spec-BHFL7H6D.js"),
+  "../plots/matrix/test/oncomatrix.spec.js": () => import("./oncomatrix.spec-MLIE6VVA.js"),
+  "../plots/plot.brainImaging.js": () => import("./plot.brainImaging-Y36M3BBW.js"),
+  "../plots/plot.disco.js": () => import("./plot.disco-YY3ITSSS.js"),
+  "../plots/plot.ssgq.js": () => import("./plot.ssgq-3UGJTTCN.js"),
+  "../plots/singleCellPlot.js": () => import("./singleCellPlot-5AAE5QGD.js"),
+  "../plots/stattable.js": () => import("./stattable-DJCYOA6Y.js"),
+  "../plots/survival/test/survival.integration.spec.js": () => import("./survival.integration.spec-IMLRYIX2.js"),
+  "../plots/table.js": () => import("./table-6VZK2B2G.js"),
+  "../plots/test/expclust.gdc.spec.js": () => import("./expclust.gdc.spec-S75GMZYG.js"),
+  "../plots/test/summary.integration.spec.js": () => import("./summary.integration.spec-PEICP7YJ.js"),
+  "../plots/volcano/test/testData.js": () => import("./testData-DRM5HWQB.js")
+});
+
+// plots/importPlot.js
+async function importPlot(chartType, notFoundMessage = "") {
+  switch (chartType) {
+    case "aggMatrixInput":
+      return await import("./AggMatrixInput-A4EATVXG.js");
+    case "aggregateMatrix":
+      return await import("./AggregateMatrix-3D36XP7Q.js");
+    case "animatedBubbleChart":
+      return await import("./animatedBubbleChart-ASVK3MS5.js");
+    case "brainImaging":
+      return await import("./brainImaging-WNEQQ3RS.js");
+    case "brainRegions":
+      return await import("./brainRegions-WKCAU4NE.js");
+    case "barchart":
+      return await import("./barchart-CM3XHZTA.js");
+    case "boxplot":
+      return await import("./BoxPlot-JNISSUMV.js");
+    case "bubbleHeatmap":
+      return await import("./bubbleHeatmap-CYHNKNYP.js");
+    case "cellTypeBubbleHeatmap":
+      return await import("./cellTypeBubbleHeatmap-N6JWAUWC.js");
+    case "correlationVolcano":
+      return await import("./CorrelationVolcano-BXXFXVHQ.js");
+    case "cuminc":
+      return await import("./Cuminc-PYG3TJSE.js");
+    case "dataDownload":
+      return await import("./dataDownload-LJPBW5RL.js");
+    case "DEinput":
+      return await import("./DEinput-YVXCVTCX.js");
+    case "dictionary":
+      return await import("./dictionary-S4MSWVZV.js");
+    case "differentialAnalysis":
+      return await import("./DifferentialAnalysis-TFWK7UE7.js");
+    case "Disco":
+      return await import("./Disco-PXBROYMP.js");
+    case "dmr":
+      return await import("./DmrPlot-G3QAPQ5I.js");
+    case "facet":
+      return await import("./facet-YFLHDE77.js");
+    case "GeneExpInput":
+      return await import("./GeneExpInput-EYNET6LR.js");
+    case "geneRanking":
+      return await import("./geneRanking-K6E7MT33.js");
+    case "genomeBrowser":
+      return await import("./GB-BLGXVCL2.js");
+    case "geomap":
+      return await import("./Geomap-OTF5DRZT.js");
+    case "grin2":
+      return await import("./grin2-WN32DXUL.js");
+    case "gsea":
+      return await import("./GSEA-ZQNLH62K.js");
+    case "imagePlot":
+      return await import("./imagePlot-BJAQGEBF.js");
+    case "numericDictTermCluster":
+      return await import("./numericDictTermCluster-6XDVVWLE.js");
+    case "profileBarchart2":
+      return await import("./barchart2-SC63JKN5.js");
+    case "profileForms":
+      return await import("./profileForms-53MNCKET.js");
+    case "profilePlot":
+      return await import("./profilePlot-SPLM6VD4.js");
+    case "profilePolar2":
+      return await import("./polar2-VK4MADEW.js");
+    case "profileRadar2":
+      return await import("./radar2-O2HJVBZE.js");
+    case "profileRadarFacility2":
+      return await import("./radarFacility2-PJHSIHK5.js");
+    case "proteinView":
+      return await import("./proteinView-ZHNMVSLF.js");
+    case "proteomeAbundance":
+      return await import("./proteomeAbundance-NH3Y4YC7.js");
+    case "proteomeCohortCompare":
+      return await import("./proteomeCohortCompare-WGUPOLE3.js");
+    case "ProteomeInput":
+      return await import("./ProteomeInput-4M2SXSJG.js");
+    case "regression":
+      return await import("./Regression-GXAACUGA.js");
+    case "report":
+      return await import("./report-47ASX5AT.js");
+    case "runChart2":
+    //See frequencyChart
+    case "frequencyChart":
+      return await import("./RunChart2-ZE7RGJEJ.js");
+    case "sampleView":
+      return await import("./sampleView-SS5PCWRL.js");
+    case "sampleScatter":
+      return await import("./scatter-DXGINZED.js");
+    case "sc":
+      return await import("./SC-4O73EKKZ.js");
+    case "studyCatalog":
+      return await import("./studyCatalog-TOGQ24WQ.js");
+    case "cohortSunburst":
+      return await import("./cohortSunburst-HEXOA7M4.js");
+    case "summarizeCnvGeneexp":
+      return await import("./summarizeCnvGeneexp-6Z3VVSMQ.js");
+    case "summarizeGeneexpSurvival":
+      return await import("./summarizeGeneexpSurvival-REIPWAEJ.js");
+    case "summarizeMutationDiagnosis":
+      return await import("./summarizeMutationDiagnosis-PVOTM3DF.js");
+    case "summarizeMutationSurvival":
+      return await import("./summarizeMutationSurvival-X7TV3EKS.js");
+    case "summarizeMutationCnv":
+      return await import("./summarizeMutationCnv-OJNIJR55.js");
+    case "summaryInput":
+      return await import("./summaryInput-53MQOUXV.js");
+    case "summary":
+      return await import("./summary-RNNIEEHQ.js");
+    case "sunburst":
+      return await import("./sunburst-MYKDYBVD.js");
+    case "swimmer":
+      return await import("./swimmer-HO32NUCE.js");
+    case "survival":
+      return await import("./survival-3IECSQKM.js");
+    case "table":
+      return await import("./table-6VZK2B2G.js");
+    case "violin":
+      return await import("./Violin-AR74D2S5.js");
+    case "volcano":
+      return await import("./Volcano-NC6CM3FY.js");
+    case "wsi":
+      return await import("./Wsi-AR2WRIQO.js");
+    default:
+      if (notFoundMessage) throw notFoundMessage;
+      return await globImport_plots_js(`../plots/${chartType}.js`);
+  }
+}
+
+export {
+  importPlot
+};
+//# sourceMappingURL=chunk-KZXFNO75.js.map