@sjcrh/proteinpaint-client 2.200.0 → 2.202.0

package/dist/chunk-X6VTVZY7.js

@@ -0,0 +1,263 @@
+import {
+  CATEGORICAL,
+  COHORT,
+  CONDITION,
+  DATE,
+  DNA_METHYLATION,
+  FLOAT,
+  GENE_EXPRESSION,
+  GENE_VARIANT,
+  INTEGER,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  METABOLITE_INTENSITY,
+  MULTIVALUE,
+  PROTEOME_ABUNDANCE,
+  PSEUDOBULK,
+  SAMPLELST,
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION,
+  SNP,
+  SNP_LIST,
+  SNP_LOCUS,
+  SSGSEA,
+  SURVIVAL,
+  TERM_COLLECTION,
+  TermTypeGroups,
+  dtTerms,
+  dtdnamethylation,
+  dtgeneexpression,
+  dtmetaboliteintensity,
+  dtproteomeabundance,
+  dtssgsea
+} from "./chunk-GEQUQ3GG.js";
+
+// ../shared/utils/dist/src/terms.js
+var ROOT_SAMPLE_TYPE = 1;
+var DEFAULT_SAMPLE_TYPE = 2;
+var NumericModes = {
+  continuous: "continuous",
+  discrete: "discrete"
+};
+var dtTermTypes = new Set(dtTerms.map((t) => t.type));
+var TermTypes2Dt = {
+  [GENE_EXPRESSION]: dtgeneexpression,
+  [SSGSEA]: dtssgsea,
+  [DNA_METHYLATION]: dtdnamethylation,
+  [METABOLITE_INTENSITY]: dtmetaboliteintensity,
+  [PROTEOME_ABUNDANCE]: dtproteomeabundance
+};
+var typeGroup = {
+  [CATEGORICAL]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [CONDITION]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [FLOAT]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [INTEGER]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [SAMPLELST]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [SURVIVAL]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [DATE]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [MULTIVALUE]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [GENE_VARIANT]: TermTypeGroups.MUTATION_CNV_FUSION,
+  [SNP]: TermTypeGroups.SNP,
+  [SNP_LIST]: TermTypeGroups.SNP_LIST,
+  [SNP_LOCUS]: TermTypeGroups.SNP_LOCUS,
+  [GENE_EXPRESSION]: TermTypeGroups.GENE_EXPRESSION,
+  [ISOFORM_EXPRESSION]: TermTypeGroups.ISOFORM_EXPRESSION,
+  [JUNCTION]: TermTypeGroups.SPLICE_JUNCTION,
+  [SSGSEA]: TermTypeGroups.SSGSEA,
+  [DNA_METHYLATION]: TermTypeGroups.DNA_METHYLATION,
+  [METABOLITE_INTENSITY]: TermTypeGroups.METABOLITE_INTENSITY,
+  [PROTEOME_ABUNDANCE]: TermTypeGroups.PROTEOME_ABUNDANCE,
+  [PSEUDOBULK]: TermTypeGroups.PSEUDOBULK,
+  [TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION,
+  [SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE,
+  [SINGLECELL_GENE_EXPRESSION]: TermTypeGroups.SINGLECELL_GENE_EXPRESSION,
+  [COHORT]: TermTypeGroups.COHORT
+};
+var nonDictTypes = /* @__PURE__ */ new Set([
+  SNP,
+  SNP_LIST,
+  SNP_LOCUS,
+  GENE_EXPRESSION,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  SSGSEA,
+  DNA_METHYLATION,
+  GENE_VARIANT,
+  METABOLITE_INTENSITY,
+  PROTEOME_ABUNDANCE,
+  PSEUDOBULK,
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION,
+  COHORT
+]);
+for (const dtTermType of dtTermTypes) {
+  nonDictTypes.add(dtTermType);
+}
+var numericTypes = /* @__PURE__ */ new Set([
+  INTEGER,
+  FLOAT,
+  GENE_EXPRESSION,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  SSGSEA,
+  DNA_METHYLATION,
+  METABOLITE_INTENSITY,
+  PROTEOME_ABUNDANCE,
+  SINGLECELL_GENE_EXPRESSION,
+  DATE,
+  PSEUDOBULK
+]);
+var dictionaryNumericTypes = /* @__PURE__ */ new Set([INTEGER, FLOAT, DATE]);
+var categoricalTypes = /* @__PURE__ */ new Set([CATEGORICAL, SNP]);
+var singleCellTerms = /* @__PURE__ */ new Set([
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION
+  /*PSEUDOBULK*/
+]);
+function isSingleCellTerm(term) {
+  if (!term) return false;
+  return singleCellTerms.has(term.type);
+}
+function isNumericTerm(term) {
+  if (!term) return false;
+  return numericTypes.has(term.type);
+}
+function isNumericTw(tw) {
+  if (!tw?.term) return false;
+  return isNumericTerm(tw.term) || tw.term.type === TERM_COLLECTION && tw.term.memberType === "numeric" && tw.type === "TermCollectionTWFraction";
+}
+function isCategoricalTerm(term) {
+  if (!term) return false;
+  return categoricalTypes.has(term.type);
+}
+function isDictionaryType(type) {
+  return !isNonDictionaryType(type);
+}
+function isNonDictionaryType(type) {
+  if (!type) throw new Error("Type is not defined");
+  return nonDictTypes.has(type);
+}
+function isNumTermCollection(term) {
+  if (!term || !term.type) throw new Error("Term or term type is not defined");
+  return term.type === TERM_COLLECTION;
+}
+function equals(t1, t2) {
+  if (!t1) throw new Error("First term is not defined ");
+  if (!t2) throw new Error("Second term is not defined ");
+  if (t1.type !== t2.type) return false;
+  if (isDictionaryType(t1.type) && isDictionaryType(t2.type) && t1.type != SAMPLELST) return t1.id === t2.id;
+  switch (t1.type) {
+    case GENE_EXPRESSION:
+      return t1.gene == t2.gene;
+    case ISOFORM_EXPRESSION:
+      return t1.isoform == t2.isoform;
+    case JUNCTION:
+      return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop && t1.strand == t2.strand;
+    case SSGSEA:
+      return t1.id == t2.id;
+    case DNA_METHYLATION:
+      return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop;
+    case METABOLITE_INTENSITY:
+    case PROTEOME_ABUNDANCE:
+      return t1.name == t2.name;
+    case GENE_VARIANT:
+      return t1.gene == t2.gene || t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop;
+    // TO DO: Add more cases
+    // case SNP_LIST:
+    // case SNP_LOCUS:
+    // case SAMPLELST:
+    default:
+      return false;
+  }
+}
+var typeMap = {
+  categorical: "Categorical",
+  condition: "Condition",
+  float: "Numerical",
+  integer: "Numerical",
+  date: "Date",
+  geneExpression: "Gene Expression",
+  isoformExpression: "Isoform Expression",
+  [JUNCTION]: "Splice junction",
+  ssGSEA: "Geneset Expression",
+  dnaMethylation: "DNA Methylation",
+  geneVariant: "Gene Variant",
+  metaboliteIntensity: "Metabolite Intensity",
+  proteomeAbundance: "Proteome Abundance",
+  proteomeDAP: "Proteome DAP",
+  multivalue: "Multi Value",
+  singleCellGeneExpression: "Single Cell, Gene Expression",
+  singleCellCellType: "Single Cell, Cell Type",
+  snplocus: "SNP Locus",
+  snp: "SNP",
+  snplst: "SNP List",
+  termCollection: "Term Collection"
+};
+function termItemType(t) {
+  switch (t.type) {
+    case JUNCTION:
+      return "Splice junction";
+    case GENE_EXPRESSION:
+    case SINGLECELL_GENE_EXPRESSION:
+      return "Gene";
+    case ISOFORM_EXPRESSION:
+      return "Isoform";
+    case SSGSEA:
+      return "Gene set";
+    case METABOLITE_INTENSITY:
+      return "Metabolite";
+    // keep adding here
+    default:
+      return "Variable";
+  }
+}
+function termType2label(type) {
+  const s = typeMap[type];
+  if (s) return s;
+  throw new Error("termType2label(): unknown value");
+}
+function getDateFromNumber(value) {
+  const year = Math.floor(value);
+  const january1st = new Date(year, 0, 1);
+  const totalDays = getDaysInYear(year);
+  const time = Math.round((value - year) * totalDays) * oneDayTime;
+  const date = new Date(january1st.getTime() + time);
+  return date;
+}
+var oneDayTime = 24 * 60 * 60 * 1e3;
+function getDateStrFromNumber(value) {
+  const date = getDateFromNumber(value);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long"
+  });
+}
+function getDaysInYear(year) {
+  const isLeap = new Date(year, 1, 29).getMonth() === 1;
+  const days = isLeap ? 366 : 365;
+  return days;
+}
+
+export {
+  ROOT_SAMPLE_TYPE,
+  DEFAULT_SAMPLE_TYPE,
+  NumericModes,
+  dtTermTypes,
+  TermTypes2Dt,
+  typeGroup,
+  numericTypes,
+  dictionaryNumericTypes,
+  isSingleCellTerm,
+  isNumericTerm,
+  isNumericTw,
+  isCategoricalTerm,
+  isDictionaryType,
+  isNonDictionaryType,
+  isNumTermCollection,
+  equals,
+  termItemType,
+  termType2label,
+  getDateFromNumber,
+  getDateStrFromNumber
+};
+//# sourceMappingURL=chunk-X6VTVZY7.js.map

package/dist/chunk-XFAL46LZ.js

@@ -0,0 +1,102 @@
+import {
+  __commonJS
+} from "./chunk-HFNDKYVF.js";
+
+// ../node_modules/debounce/index.js
+var require_debounce = __commonJS({
+  "../node_modules/debounce/index.js"(exports, module) {
+    function debounce(func, wait, immediate) {
+      var timeout, args, context, timestamp, result;
+      if (null == wait) wait = 100;
+      function later() {
+        var last = Date.now() - timestamp;
+        if (last < wait && last >= 0) {
+          timeout = setTimeout(later, wait - last);
+        } else {
+          timeout = null;
+          if (!immediate) {
+            result = func.apply(context, args);
+            context = args = null;
+          }
+        }
+      }
+      ;
+      var debounced = function() {
+        context = this;
+        args = arguments;
+        timestamp = Date.now();
+        var callNow = immediate && !timeout;
+        if (!timeout) timeout = setTimeout(later, wait);
+        if (callNow) {
+          result = func.apply(context, args);
+          context = args = null;
+        }
+        return result;
+      };
+      debounced.clear = function() {
+        if (timeout) {
+          clearTimeout(timeout);
+          timeout = null;
+        }
+      };
+      debounced.flush = function() {
+        if (timeout) {
+          result = func.apply(context, args);
+          context = args = null;
+          clearTimeout(timeout);
+          timeout = null;
+        }
+      };
+      return debounced;
+    }
+    debounce.debounce = debounce;
+    module.exports = debounce;
+  }
+});
+
+// termsetting/HandlerBase.ts
+var HandlerBase = class {
+  //tw: TwBase
+  constructor(opts) {
+    this.termsetting = opts.termsetting;
+  }
+  showEditMenu(_) {
+  }
+  getPillStatus(_) {
+    const tw = this.termsetting.tw;
+    return tw.getStatus?.() || { text: "" };
+  }
+  // this is equivalent to getPillNameDefault()
+  getPillName(d) {
+    const self = this.termsetting;
+    if (!self.opts.abbrCutoff) return d.name;
+    return d.name.length <= self.opts.abbrCutoff + 2 ? d.name : '<label title="' + d.name + '">' + d.name.substring(0, self.opts.abbrCutoff) + "...</label>";
+  }
+  applyEdits() {
+  }
+  undoEdits() {
+  }
+  /* a term with valueConversion{} stores its values in fromUnit (e.g. day) but shows them to
+  users in toUnit (e.g. year). the inputs of the numeric edit menus (bin boundaries, knots) are
+  in the stored unit, so tell the user which unit they are typing in */
+  mayShowValueconversionMsg(div) {
+    const vc = this.termsetting.tw?.term?.valueConversion;
+    if (!vc) return;
+    div.append("div").style("margin", "0px 0px 10px 10px").style("opacity", 0.6).text(`Note: using values by the unit of ${vc.toUnit}.`);
+  }
+  showLoading(_div) {
+    const self = this.termsetting;
+    const div = _div || self.dom.tip.d;
+    div.selectAll("*").remove();
+    this.dom.loadingDiv = div.append("div").style("margin", "15px").text("Loading ...");
+  }
+  hideLoading() {
+    this.dom.loadingDiv?.remove();
+  }
+};
+
+export {
+  require_debounce,
+  HandlerBase
+};
+//# sourceMappingURL=chunk-XFAL46LZ.js.map

package/dist/chunk-XFAL46LZ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../node_modules/debounce/index.js", "../termsetting/HandlerBase.ts"],
+  "sourcesContent": ["/**\n * Returns a function, that, as long as it continues to be invoked, will not\n * be triggered. The function will be called after it stops being called for\n * N milliseconds. If `immediate` is passed, trigger the function on the\n * leading edge, instead of the trailing. The function also has a property 'clear' \n * that is a function which will clear the timer to prevent previously scheduled executions. \n *\n * @source underscore.js\n * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/\n * @param {Function} function to wrap\n * @param {Number} timeout in ms (`100`)\n * @param {Boolean} whether to execute at the beginning (`false`)\n * @api public\n */\nfunction debounce(func, wait, immediate){\n  var timeout, args, context, timestamp, result;\n  if (null == wait) wait = 100;\n\n  function later() {\n    var last = Date.now() - timestamp;\n\n    if (last < wait && last >= 0) {\n      timeout = setTimeout(later, wait - last);\n    } else {\n      timeout = null;\n      if (!immediate) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n    }\n  };\n\n  var debounced = function(){\n    context = this;\n    args = arguments;\n    timestamp = Date.now();\n    var callNow = immediate && !timeout;\n    if (!timeout) timeout = setTimeout(later, wait);\n    if (callNow) {\n      result = func.apply(context, args);\n      context = args = null;\n    }\n\n    return result;\n  };\n\n  debounced.clear = function() {\n    if (timeout) {\n      clearTimeout(timeout);\n      timeout = null;\n    }\n  };\n  \n  debounced.flush = function() {\n    if (timeout) {\n      result = func.apply(context, args);\n      context = args = null;\n      \n      clearTimeout(timeout);\n      timeout = null;\n    }\n  };\n\n  return debounced;\n};\n\n// Adds compatibility for ES modules\ndebounce.debounce = debounce;\n\nmodule.exports = debounce;\n", "import type { Handler, UseCase } from './types'\nimport type { TermSetting } from './TermSetting.ts'\nimport type { TwBase } from '#tw'\n\nexport class HandlerBase implements Handler {\n\ttermsetting: TermSetting\n\tdom!: {\n\t\t[name: string]: any\n\t}\n\t//tw: TwBase\n\n\tconstructor(opts) {\n\t\tthis.termsetting = opts.termsetting\n\t\t//this.tw = opts.termsetting.tw\n\t}\n\n\tshowEditMenu(_) {\n\t\t//ignore\n\t}\n\n\tgetPillStatus(_?: UseCase) {\n\t\tconst tw = this.termsetting.tw as any as TwBase\n\t\treturn tw.getStatus?.() || { text: '' }\n\t}\n\n\t// this is equivalent to getPillNameDefault()\n\tgetPillName(d) {\n\t\tconst self = this.termsetting\n\t\tif (!self.opts.abbrCutoff) return d.name\n\t\treturn d.name.length <= self.opts.abbrCutoff + 2\n\t\t\t? d.name\n\t\t\t: '<label title=\"' + d.name + '\">' + d.name.substring(0, self.opts.abbrCutoff) + '...' + '</label>'\n\t}\n\n\tapplyEdits() {\n\t\t// ignore\n\t}\n\n\tundoEdits() {\n\t\t// ignore\n\t}\n\n\t/* a term with valueConversion{} stores its values in fromUnit (e.g. day) but shows them to\n\tusers in toUnit (e.g. year). the inputs of the numeric edit menus (bin boundaries, knots) are\n\tin the stored unit, so tell the user which unit they are typing in */\n\tmayShowValueconversionMsg(div: any) {\n\t\tconst vc = (this.termsetting.tw as any)?.term?.valueConversion\n\t\tif (!vc) return\n\t\tdiv\n\t\t\t.append('div')\n\t\t\t.style('margin', '0px 0px 10px 10px')\n\t\t\t.style('opacity', 0.6)\n\t\t\t// the editors show and read values in the user-facing unit, so that is the unit to name\n\t\t\t.text(`Note: using values by the unit of ${vc.toUnit}.`)\n\t}\n\n\tshowLoading(_div?: any) {\n\t\tconst self = this.termsetting\n\t\tconst div = _div || self.dom.tip.d\n\t\tdiv.selectAll('*').remove()\n\t\tthis.dom.loadingDiv = div.append('div').style('margin', '15px').text('Loading ...')\n\t}\n\n\thideLoading() {\n\t\tthis.dom.loadingDiv?.remove()\n\t}\n}\n"],
+  "mappings": ";;;;;AAAA;AAAA;AAcA,aAAS,SAAS,MAAM,MAAM,WAAU;AACtC,UAAI,SAAS,MAAM,SAAS,WAAW;AACvC,UAAI,QAAQ,KAAM,QAAO;AAEzB,eAAS,QAAQ;AACf,YAAI,OAAO,KAAK,IAAI,IAAI;AAExB,YAAI,OAAO,QAAQ,QAAQ,GAAG;AAC5B,oBAAU,WAAW,OAAO,OAAO,IAAI;AAAA,QACzC,OAAO;AACL,oBAAU;AACV,cAAI,CAAC,WAAW;AACd,qBAAS,KAAK,MAAM,SAAS,IAAI;AACjC,sBAAU,OAAO;AAAA,UACnB;AAAA,QACF;AAAA,MACF;AAAC;AAED,UAAI,YAAY,WAAU;AACxB,kBAAU;AACV,eAAO;AACP,oBAAY,KAAK,IAAI;AACrB,YAAI,UAAU,aAAa,CAAC;AAC5B,YAAI,CAAC,QAAS,WAAU,WAAW,OAAO,IAAI;AAC9C,YAAI,SAAS;AACX,mBAAS,KAAK,MAAM,SAAS,IAAI;AACjC,oBAAU,OAAO;AAAA,QACnB;AAEA,eAAO;AAAA,MACT;AAEA,gBAAU,QAAQ,WAAW;AAC3B,YAAI,SAAS;AACX,uBAAa,OAAO;AACpB,oBAAU;AAAA,QACZ;AAAA,MACF;AAEA,gBAAU,QAAQ,WAAW;AAC3B,YAAI,SAAS;AACX,mBAAS,KAAK,MAAM,SAAS,IAAI;AACjC,oBAAU,OAAO;AAEjB,uBAAa,OAAO;AACpB,oBAAU;AAAA,QACZ;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAGA,aAAS,WAAW;AAEpB,WAAO,UAAU;AAAA;AAAA;;;ACjEV,IAAM,cAAN,MAAqC;AAAA;AAAA,EAO3C,YAAY,MAAM;AACjB,SAAK,cAAc,KAAK;AAAA,EAEzB;AAAA,EAEA,aAAa,GAAG;AAAA,EAEhB;AAAA,EAEA,cAAc,GAAa;AAC1B,UAAM,KAAK,KAAK,YAAY;AAC5B,WAAO,GAAG,YAAY,KAAK,EAAE,MAAM,GAAG;AAAA,EACvC;AAAA;AAAA,EAGA,YAAY,GAAG;AACd,UAAM,OAAO,KAAK;AAClB,QAAI,CAAC,KAAK,KAAK,WAAY,QAAO,EAAE;AACpC,WAAO,EAAE,KAAK,UAAU,KAAK,KAAK,aAAa,IAC5C,EAAE,OACF,mBAAmB,EAAE,OAAO,OAAO,EAAE,KAAK,UAAU,GAAG,KAAK,KAAK,UAAU,IAAI;AAAA,EACnF;AAAA,EAEA,aAAa;AAAA,EAEb;AAAA,EAEA,YAAY;AAAA,EAEZ;AAAA;AAAA;AAAA;AAAA,EAKA,0BAA0B,KAAU;AACnC,UAAM,KAAM,KAAK,YAAY,IAAY,MAAM;AAC/C,QAAI,CAAC,GAAI;AACT,QACE,OAAO,KAAK,EACZ,MAAM,UAAU,mBAAmB,EACnC,MAAM,WAAW,GAAG,EAEpB,KAAK,qCAAqC,GAAG,MAAM,GAAG;AAAA,EACzD;AAAA,EAEA,YAAY,MAAY;AACvB,UAAM,OAAO,KAAK;AAClB,UAAM,MAAM,QAAQ,KAAK,IAAI,IAAI;AACjC,QAAI,UAAU,GAAG,EAAE,OAAO;AAC1B,SAAK,IAAI,aAAa,IAAI,OAAO,KAAK,EAAE,MAAM,UAAU,MAAM,EAAE,KAAK,aAAa;AAAA,EACnF;AAAA,EAEA,cAAc;AACb,SAAK,IAAI,YAAY,OAAO;AAAA,EAC7B;AACD;",
+  "names": []
+}

package/dist/chunk-Y2UCJ33M.js

@@ -0,0 +1,263 @@
+import {
+  Matrix
+} from "./chunk-USH6NWXA.js";
+import {
+  hierCluster_renderers_exports
+} from "./chunk-UONOFG2J.js";
+import {
+  hierCluster_interactivity_exports
+} from "./chunk-4RWLKZMS.js";
+import {
+  filterJoin,
+  getNormalRoot
+} from "./chunk-73PFJ2VF.js";
+import {
+  clusterMethodLst,
+  distanceMethodLst,
+  dofetch3
+} from "./chunk-X4QQRHFB.js";
+import {
+  TermTypes2Dt,
+  dictionaryNumericTypes
+} from "./chunk-X6VTVZY7.js";
+import {
+  deepEqual,
+  getCompInit
+} from "./chunk-H6INPPUC.js";
+import {
+  colorScaleMap
+} from "./chunk-GEQUQ3GG.js";
+import {
+  extent,
+  linear
+} from "./chunk-UJELJXJG.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-Y2UCJ33M.js.map