@sjcrh/proteinpaint-client 2.212.0 → 2.213.0

package/dist/chunk-OB3S6QYD.js

@@ -0,0 +1,243 @@
+import {
+  keyupEnter
+} from "./chunk-QI6X4V43.js";
+import {
+  get_bin_label,
+  get_bin_range_equation
+} from "./chunk-YU7CVG4B.js";
+import {
+  toStoredUnit,
+  toUserUnit
+} from "./chunk-W5J3LTYS.js";
+
+// termsetting/handlers/NumCustomBinEditor.ts
+var NumCustomBinEditor = class {
+  constructor(editHandler) {
+    this.dom = {};
+    this.editHandler = editHandler;
+    this.opts = editHandler.opts;
+    this.tw = editHandler.tw;
+    this.termsetting = editHandler.termsetting;
+  }
+  /* bin boundaries are stored in the term's own unit but entered and shown in its user-facing one.
+  both are identity functions unless the term declares valueConversion{} */
+  toDisplay(v) {
+    return toUserUnit(v, this.tw.term);
+  }
+  toStored(v) {
+    return toStoredUnit(v, this.tw.term);
+  }
+  async render(div) {
+    this.tw = this.editHandler.tw;
+    const isRemounting = !!this.dom.inputsDiv && this.editHandler.dom.binsDiv?.node().contains(this.dom.inputsDiv.node());
+    if (!isRemounting) this.q = this.getDefaultQ();
+    await this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+    if (isRemounting) return;
+    if (this.dom.inputsDiv) {
+      this.dom.inputsDiv.remove();
+      delete this.dom.inputsDiv;
+    }
+    this.dom.inputsDiv = div.append("div").style("display", "flex").style("width", "100%");
+    this.renderCustomBinInputs();
+  }
+  getBoundaryOpts() {
+    return {
+      values: this.q.lst.slice(1).map((bin) => ({ x: this.toDisplay(bin.startunbounded ? bin.stop : bin.start), isDraggable: true })),
+      // the dragged value arrives in display units, matching what the textarea holds
+      callback: (d, value) => {
+        const boundaryValues = this.q.lst.slice(1).map((d2) => "start" in d2 ? this.toDisplay(d2.start) : "");
+        boundaryValues[d.index] = value;
+        this.dom.customBinBoundaryInput.property("value", boundaryValues.join("\n"));
+        this.handleInputChange("drag");
+        return 0;
+      }
+    };
+  }
+  getDefaultQ() {
+    if (this.tw.q.mode == "discrete" && this.tw.q.type == "custom-bin") {
+      const copy = JSON.parse(JSON.stringify(this.tw.q));
+      copy.lst.forEach((bin) => {
+        if (!bin.label) bin.label = get_bin_label(bin, this.tw.q, this.tw.term.valueConversion);
+        bin.range = get_bin_range_equation(bin, this.tw.q, this.tw.term.valueConversion);
+      });
+      return copy;
+    }
+    const { min, max } = this.editHandler.handler.density_data;
+    const defaultCustomBoundary = (
+      /* when no sample is annotated by this term,
+      minvalue and maxvalue are both null
+      setting defaultCustomBoundary to arbitrary "0" will allow existing UI to work
+      but remains to be evaluated if is really okay to use 0
+      */
+      !Number.isFinite(min) || !Number.isFinite(max) ? 0 : (
+        // minvalue and maxvalue is valid number
+        max != min ? min + (max - min) / 2 : max
+      )
+    );
+    const firstBin = {
+      startunbounded: true,
+      startinclusive: false,
+      stopinclusive: false,
+      stop: +defaultCustomBoundary.toFixed(this.tw.term.type == "integer" ? 0 : 2)
+    };
+    const lastBin = {
+      stopunbounded: true,
+      startinclusive: true,
+      stopinclusive: false,
+      start: +defaultCustomBoundary.toFixed(this.tw.term.type == "integer" ? 0 : 2)
+    };
+    return {
+      mode: "discrete",
+      type: "custom-bin",
+      lst: [
+        // Type '{ label: any; range: any; startunbounded: boolean; startinclusive: boolean; stopinclusive: boolean; stop: number; }' is not assignable to type 'StartUnboundedBin | FullyBoundedBin'.
+        // Property 'start' is missing in type '{ label: any; range: any; startunbounded: boolean; startinclusive: boolean; stopinclusive: boolean; stop: number; }' but required in type 'FullyBoundedBin'.
+        {
+          ...firstBin,
+          label: get_bin_label(firstBin, this.tw.q, this.tw.term.valueConversion),
+          range: get_bin_range_equation(firstBin, this.tw.q, this.tw.term.valueConversion)
+        },
+        {
+          ...lastBin,
+          label: get_bin_label(lastBin, this.tw.q, this.tw.term.valueConversion),
+          range: get_bin_range_equation(lastBin, this.tw.q, this.tw.term.valueConversion)
+        }
+        //satisfies StopUnboundedBin
+      ]
+    };
+  }
+  /******************* Functions for Numerical Custom size bins *******************/
+  renderCustomBinInputs() {
+    const q = this.q;
+    const boundaryDiv = this.dom.inputsDiv.append("div").style("margin-right", "20px");
+    this.dom.rangeAndLabelDiv = this.dom.inputsDiv.append("div");
+    boundaryDiv.append("div").style("margin-bottom", "5px").style("color", "rgb(136, 136, 136)").text("Bin boundaries");
+    this.dom.customBinBoundaryInput = boundaryDiv.append("textarea").style("width", "100px").style("height", "70px").text(
+      q.lst.slice(1).map((d) => "start" in d ? this.toDisplay(d.start) : "").join("\n")
+    ).on("change", () => this.handleInputChange()).on("keyup", async (event) => {
+      if (!keyupEnter(event) && event.key != 8 && event.key != "Enter") return;
+      if (!this.dom.inputsDiv.selectAll("input").node().value) return;
+      this.handleInputChange();
+    });
+    boundaryDiv.append("div").style("font-size", ".6em").style("margin-left", "1px").style("color", "#858585").html("Enter numeric values </br>seperated by ENTER");
+    this.renderBoundaryInputDivs();
+  }
+  renderBoundaryInputDivs() {
+    const data = this.q.lst;
+    const holder = this.dom.rangeAndLabelDiv;
+    holder.selectAll("*").remove();
+    const grid = holder.append("div").style("display", "grid").style("grid-template-columns", "auto auto").style("column-gap", "20px").style("align-items", "center");
+    grid.append("div").style("margin-bottom", "3px").style("color", "rgb(136, 136, 136)").text("Range");
+    grid.append("div").style("margin-bottom", "3px").style("color", "rgb(136, 136, 136)").text("Bin label");
+    for (const d of data) {
+      grid.append("div").attr("name", "range").html(d.range);
+      grid.append("div").append("input").attr("type", "text").style("margin", "2px 0px").property("value", d.label).on("change", function() {
+        d.label = this.value;
+      });
+    }
+    this.dom.customBinRanges = this.dom.inputsDiv.selectAll('div[name="range"]').data(data);
+    this.dom.customBinLabelInput = this.dom.inputsDiv.selectAll("input").data(data);
+  }
+  handleInputChange(eventType = "") {
+    const self = this.tw;
+    const inputs = this.dom.inputsDiv.selectAll("input");
+    inputs.property("value", "");
+    const data = this.processCustomBinInputs();
+    if (data == void 0) {
+      return;
+    }
+    if (self.q.hiddenValues) this.tw.q.hiddenValues = self.q.hiddenValues;
+    if (this.binsChanged(data, this.q.lst)) {
+      this.q.lst = data;
+    }
+    this.renderBoundaryInputDivs();
+    if (eventType != "drag") this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+  binsChanged(data, qlst) {
+    if (data.length != qlst.length) return true;
+    if (Object.keys(data[0]).length !== Object.keys(qlst[0]).length) return true;
+    for (const [i, bin] of qlst.entries()) {
+      for (const k of Object.keys(bin)) {
+        if (bin[k] && bin[k] !== data[i][k]) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  processCustomBinInputs() {
+    const self = this.termsetting;
+    const startinclusive = this.editHandler.boundaryInclusion == "startinclusive";
+    const stopinclusive = this.editHandler.boundaryInclusion == "stopinclusive";
+    const inputs = this.dom.inputsDiv.node().querySelectorAll("input");
+    const inputData = this.dom.customBinBoundaryInput.property("value").split("\n").filter((d) => d != "" && !isNaN(d));
+    const trackBins = new Set(inputData);
+    if (!trackBins.size) return this.tw.q.lst;
+    const sortedBins = Array.from(trackBins).map((v) => this.toStored(Number(v))).sort((a, b) => a - b);
+    const data = [
+      // first bin: StartUnbounded type
+      {
+        startunbounded: true,
+        stop: sortedBins[0],
+        startinclusive: false,
+        stopinclusive,
+        label: inputs[0].value
+      }
+    ];
+    if (!data[0].label) data[0].label = get_bin_label(data[0], self.q, self.term.valueConversion);
+    if (!data[0].range) data[0].range = get_bin_range_equation(data[0], self.q, self.term.valueConversion);
+    for (const [i, d] of sortedBins.entries()) {
+      let bin;
+      const label = inputs[i + 1]?.value || "";
+      if (i !== trackBins.size - 1) {
+        bin = {
+          start: +d,
+          startinclusive,
+          stopinclusive,
+          stop: sortedBins[i + 1],
+          label
+          //range: ''
+        };
+      } else {
+        bin = {
+          start: +d,
+          startinclusive,
+          stopinclusive: false,
+          stopunbounded: true,
+          label
+          //range: ''
+        };
+      }
+      if (bin.label === "" || bin.label === void 0) bin.label = get_bin_label(bin, self.q, self.term.valueConversion);
+      if (bin.range === "" || bin.range === void 0)
+        bin.range = get_bin_range_equation(bin, self.q, self.term.valueConversion);
+      data.push(bin);
+    }
+    return data;
+  }
+  getEditedQ(destroyDom = true) {
+    const lst = this.processCustomBinInputs();
+    if (destroyDom) {
+      for (const name of Object.keys(this.dom)) {
+        this.dom[name].remove();
+        delete this.dom[name];
+      }
+    }
+    return {
+      mode: "discrete",
+      type: "custom-bin",
+      lst
+    };
+  }
+  undoEdits() {
+    this.q = this.getDefaultQ();
+    this.dom.inputsDiv.selectAll("*").remove();
+    this.renderCustomBinInputs();
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+};
+
+export {
+  NumCustomBinEditor
+};
+//# sourceMappingURL=chunk-OB3S6QYD.js.map

package/dist/chunk-OLV3Q6TN.js

@@ -0,0 +1,55 @@
+import {
+  colorinframe
+} from "./chunk-QI6X4V43.js";
+import {
+  IN_frame,
+  OUT_frame
+} from "./chunk-57Z4VYLM.js";
+
+// src/spliceevent.phrase.js
+function spliceevent_phrase_default(evt) {
+  const htmls = [];
+  if (evt.isaltexon || evt.isskipexon) {
+    const exonstart = Math.min(...evt.skippedexon);
+    const exonstop = Math.max(...evt.skippedexon);
+    htmls.push(
+      '<div style="display:inline-block">' + (exonstart == exonstop ? "exon " + (exonstart + 1) : "exons " + (exonstart + 1) + "-" + (exonstop + 1)) + " " + (evt.isaltexon ? "alternative usage" : "skipping") + "</div>"
+    );
+    if (evt.isaltexon) {
+      htmls.push(
+        "<div class=sja_tinylogo_body>" + evt.gmB.isoform + ", " + evt.gmA.isoform + "</div><div class=sja_tinylogo_head>ISOFORMS</div>"
+      );
+    } else {
+      htmls.push("<div class=sja_tinylogo_body>" + evt.gm.isoform + "</div><div class=sja_tinylogo_head>ISOFORM</div>");
+    }
+    if (evt.junctionB.data) {
+      htmls.push(
+        "<div class=sja_tinylogo_body>" + evt.junctionB.data.length + "</div><div class=sja_tinylogo_head>SAMPLE" + (evt.junctionB.data.length > 1 ? "S" : "") + "</div>"
+      );
+    }
+    htmls.push("<div class=sja_tinylogo_body>" + evt.percentage + " %</div><div class=sja_tinylogo_head>PERCENT</div>");
+    if (evt.framenocheck) {
+      if (evt.utr3) {
+        htmls.push(`<div class=sja_tinylogo_body style="background-color:#ededed">3' UTR</div>`);
+      } else if (evt.utr5) {
+        htmls.push(`<div class=sja_tinylogo_body style="background-color:#ededed">5' UTR</div>`);
+      }
+    } else if (evt.frame == IN_frame) {
+      htmls.push(
+        '<div class=sja_tinylogo_body style="background-color:' + colorinframe + ';color:white">IN</div><div class=sja_tinylogo_head>FRAME</div>'
+      );
+    } else if (evt.frame == OUT_frame) {
+      htmls.push("<div class=sja_tinylogo_body>OUT</div><div class=sja_tinylogo_head>FRAME</div>");
+    } else {
+      htmls.push("<div class=sja_tinylogo_body>?</div><div class=sja_tinylogo_head>FRAME</div>");
+    }
+  } else {
+    return "unknown event type!!";
+  }
+  return htmls.join(" ");
+}
+
+export {
+  spliceevent_phrase_default
+};
+//# sourceMappingURL=chunk-OLV3Q6TN.js.map

package/dist/chunk-PRPQ654B.js

@@ -0,0 +1,263 @@
+import {
+  Matrix
+} from "./chunk-MIG3QAYD.js";
+import {
+  hierCluster_renderers_exports
+} from "./chunk-7AOA5WZY.js";
+import {
+  hierCluster_interactivity_exports
+} from "./chunk-3BBUXNES.js";
+import {
+  filterJoin,
+  getNormalRoot
+} from "./chunk-QI6X4V43.js";
+import {
+  clusterMethodLst,
+  distanceMethodLst,
+  dofetch3
+} from "./chunk-YU7CVG4B.js";
+import {
+  TermTypes2Dt,
+  dictionaryNumericTypes
+} from "./chunk-RU2UHH7M.js";
+import {
+  colorScaleMap
+} from "./chunk-57Z4VYLM.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-PRPQ654B.js.map