@sjcrh/proteinpaint-client 2.181.0 → 2.182.0

package/dist/chunk-GO5SIPFE.js

@@ -0,0 +1,194 @@
+import {
+  sample_match_termvaluesetting
+} from "./chunk-6MSCYO7K.js";
+import {
+  isDictionaryType
+} from "./chunk-MDL2HG3N.js";
+import {
+  __export
+} from "./chunk-HFNDKYVF.js";
+
+// plots/matrix/matrix.data.js
+var matrix_data_exports = {};
+__export(matrix_data_exports, {
+  applyLegendValueFilter: () => applyLegendValueFilter,
+  getMatrixRequestOpts: () => getMatrixRequestOpts,
+  mayRequireToken: () => mayRequireToken,
+  setData: () => setData
+});
+function mayRequireToken(tokenMessage = "") {
+  const message = tokenMessage || this.state.tokenVerificationMessage;
+  if (!message && this.state.hasVerifiedToken) {
+    this.dom.errdiv.style("display", "none").html();
+    this.dom.controls.style("display", this.opts.controls ? "inline-block" : "");
+    this.dom.svg.style("display", "");
+    return false;
+  } else {
+    this.dom.errdiv.style("display", "").html(message || "Requires login");
+    this.dom.controls.style("display", "none");
+    this.dom.svg.style("display", "none");
+    return true;
+  }
+}
+function getMatrixRequestOpts(state, config) {
+  const terms = [];
+  const termgroups = this.chartType == "hierCluster" ? config.termgroups.filter((grp) => grp.type != "hierCluster") : config.termgroups;
+  for (const grp of termgroups) {
+    terms.push(...getNormalizedTwLstCopy(grp.lst));
+  }
+  if (config.divideBy) terms.push(normalizeTwForRequest(structuredClone(config.divideBy)));
+  const opts = {
+    terms,
+    filter: state.filter,
+    filter0: state.filter0,
+    maxGenes: state.config.settings.matrix.maxGenes,
+    /*********** quick fix
+    when the flag is true, set artificially large number to ensure all genes are sent in one query
+    this avoids changing getAnnotatedSampleData()
+    additional non-matrix app that calls getAnnotatedSampleData will NEED THE SAME FIX
+    */
+    termsPerRequest: this.app.vocabApi.termdbConfig.queries?.snvindel?.byisoform?.processTwsInOneQuery ? 1e3 : 1
+  };
+  if (this.chartType == "hierCluster") {
+    opts.isHierCluster = 1;
+  }
+  return opts;
+}
+function getNormalizedTwLstCopy(twlst) {
+  const lst = [];
+  for (const tw of twlst) {
+    if (tw.type && tw.constructor.name != "Object") lst.push(tw);
+    else lst.push(normalizeTwForRequest(tw));
+  }
+  lst.forEach(normalizeTwForRequest);
+  lst.sort(sortTwLst);
+  return lst;
+}
+function normalizeTwForRequest(_tw) {
+  const tw = structuredClone(_tw);
+  if (!tw?.term) return;
+  delete tw.term.category2samplecount;
+  if (isDictionaryType(tw.term.type) && tw.term.type !== "samplelst") delete tw.term.values;
+  return tw;
+}
+function sortTwLst(twa, twb) {
+  const a = twa?.$id || twa.term?.id || twa?.term?.name;
+  const b = twb?.$id || twb.term?.id || twb?.term?.name;
+  return a < b ? -1 : 1;
+}
+async function setData(_data) {
+  const opts = this.currRequestOpts?.matrix || this.getMatrixRequestOpts(this.state, this.config);
+  this.numTerms = opts.terms.length;
+  opts.loadingDiv = this.chartType != "hierCluster" && this.dom.loadingDiv;
+  opts.signal = this.api.getAbortSignal();
+  const data = await this.app.vocabApi.getAnnotatedSampleData(opts, _data);
+  this.data = data;
+  this.origData = structuredClone(this.data);
+  this.sampleIdMap = {};
+  for (const d of this.data.lst) {
+    this.sampleIdMap[d.sample] = d._ref_.label;
+  }
+}
+function applyLegendValueFilter() {
+  const self = this;
+  if (!self.config.legendValueFilter.lst.length && !self.config.legendGrpFilter.lst.length) return;
+  for (const grpFilter of self.config.legendGrpFilter.lst) {
+    if (grpFilter.dt) {
+      const filteredOutCats = /* @__PURE__ */ new Set();
+      for (const oneSampleData of self.origData.lst) {
+        for (const annoForOneTerm of Object.values(oneSampleData)) {
+          if (annoForOneTerm.values) {
+            const newValues = [];
+            for (const v of annoForOneTerm.values) {
+              if (!(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))) {
+                newValues.push(v);
+              } else {
+                filteredOutCats.add(v.class);
+              }
+            }
+            annoForOneTerm.values = newValues;
+          }
+        }
+      }
+      grpFilter.filteredOutCats = [...filteredOutCats];
+      for (const oneSampleData of Object.values(self.origData.samples)) {
+        for (const annoForOneTerm of Object.values(oneSampleData)) {
+          if (annoForOneTerm.values)
+            annoForOneTerm.values = annoForOneTerm.values.filter(
+              (v) => !(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))
+            );
+        }
+      }
+    }
+  }
+  const geneVariant$ids = Object.values(self.data.refs.byTermId).filter((v) => v.term?.type == "geneVariant").map((v) => v.$id);
+  const data = { samples: {}, lst: [], refs: self.data.refs };
+  const onlyHardFilter = structuredClone(self.config.legendValueFilter);
+  onlyHardFilter.lst = onlyHardFilter.lst.filter(
+    (l) => !l.tvs.legendFilterType || l.tvs.legendFilterType !== "geneVariant_soft"
+  );
+  for (const row of self.origData.lst) {
+    const include = sample_match_termvaluesetting(row, onlyHardFilter, geneVariant$ids);
+    if (include || self.chartType == "hierCluster") {
+      data.samples[row.sample] = row;
+      data.lst.push(row);
+    }
+  }
+  for (const valFilter of self.config.legendValueFilter.lst) {
+    if (valFilter.tvs.legendFilterType !== "geneVariant_soft") continue;
+    const tvsV = valFilter.tvs.values[0];
+    const filteredOutCats = /* @__PURE__ */ new Set();
+    for (const oneSampleData of data.lst) {
+      for (const annoForOneTerm of Object.values(oneSampleData)) {
+        if (annoForOneTerm.values) {
+          const newValues = [];
+          for (const v of annoForOneTerm.values) {
+            if (!(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))) {
+              newValues.push(v);
+            } else {
+              filteredOutCats.add(v.class);
+            }
+          }
+          annoForOneTerm.values = newValues;
+        }
+      }
+    }
+    valFilter.filteredOutCats = [...filteredOutCats];
+    for (const oneSampleData of Object.values(data.samples)) {
+      for (const annoForOneTerm of Object.values(oneSampleData)) {
+        if (annoForOneTerm.values)
+          annoForOneTerm.values = annoForOneTerm.values.filter(
+            (v) => !(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))
+          );
+      }
+    }
+  }
+  if (self.chartType !== "hierCluster" && geneVariant$ids.length && self.app.vocabApi.vocab?.dslabel == "GDC")
+    remove_empty_sample(data, geneVariant$ids);
+  self.data = data;
+}
+function remove_empty_sample(data) {
+  for (const oneSampleData of data.lst) {
+    let removeSample = true;
+    for (const [key, annoForOneTerm] of Object.entries(oneSampleData)) {
+      if (!annoForOneTerm.values) continue;
+      const annoType = data.refs.byTermId[key].term.type;
+      if (annoType != "geneVariant") continue;
+      if (annoForOneTerm.values.length) removeSample = false;
+    }
+    if (removeSample) {
+      data.lst = data.lst.filter((dl) => dl.sample !== oneSampleData.sample);
+      delete data.samples[parseInt(oneSampleData.sample)];
+    }
+  }
+  return data;
+}
+
+export {
+  mayRequireToken,
+  getMatrixRequestOpts,
+  setData,
+  applyLegendValueFilter,
+  matrix_data_exports
+};
+//# sourceMappingURL=chunk-GO5SIPFE.js.map

package/dist/chunk-GPOECA3V.js

@@ -0,0 +1,386 @@
+import {
+  CNVkey2order
+} from "./chunk-UR3C4SCH.js";
+import {
+  TermTypes
+} from "./chunk-MDL2HG3N.js";
+import {
+  colorScaleMap,
+  dtcnv,
+  dtfusionrna,
+  dtgeneexpression,
+  dtsnvindel,
+  dtsv
+} from "./chunk-IGEQI6MR.js";
+import {
+  convertUnits
+} from "./chunk-BEWDIM6H.js";
+
+// plots/matrix/matrix.cells.js
+function setNumericCellProps(cell, tw, anno, value, s, t, self2, width, height, dx, dy, i) {
+  const key = anno.key;
+  const values = tw.term.values || {};
+  cell.label = "label" in anno ? anno.label : values[key]?.label ? values[key].label : key;
+  cell.fill = self2.config.settings.matrix.twSpecificSettings?.[tw.$id]?.[key]?.color || anno.color || values[anno.key]?.color || self2.data.refs.byTermId?.[tw.$id]?.bins?.find((b) => anno.key == b.name)?.color;
+  cell.order = t.ref.bins ? t.ref.bins.findIndex((bin) => bin.name == key) : 0;
+  if (tw.q?.mode == "continuous") {
+    const twSpecificSettings = self2.config.settings.matrix.twSpecificSettings;
+    if (!twSpecificSettings[tw.$id]) twSpecificSettings[tw.$id] = {};
+    const twSettings = twSpecificSettings[tw.$id];
+    if (!twSettings.contBarH) twSettings.contBarH = s.barh;
+    if (!("gap" in twSettings)) twSettings.contBarGap = 4;
+    const specialValue = tw.term.values?.[cell.key];
+    if (specialValue?.uncomputable) {
+      cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+      cell.y = height * i;
+      cell.height = twSettings.contBarH;
+      cell.fill = "transparent";
+      const group = tw.legend?.group || tw.$id;
+      return;
+    }
+    cell.fill = self2.config.settings.matrix.twSpecificSettings?.[tw.$id]?.contBarColor || "#555";
+    if (s.transpose) {
+      cell.height = t.scale(cell.key);
+      cell.x = twSettings.contBarGap;
+    } else {
+      const vc = cell.term.valueConversion;
+      let renderV = vc ? cell.key * vc.scaleFactor : cell.key;
+      if (tw.q.convert2ZScore) {
+        renderV = (renderV - t.mean) / t.std;
+        cell.fill = renderV > 0 ? "#FF6666" : "#6666FF";
+        cell.zscoreLabel = ` (Z-score: ${renderV.toFixed(2)})`;
+      }
+      cell.label = "label" in anno ? anno.label : values[key]?.label ? values[key].label : tw.term.unit ? `${cell.key.toFixed(2)} ${tw.term.unit}` : cell.key.toFixed(2);
+      cell.height = renderV >= 0 ? t.scales.pos(renderV) : t.scales.neg(renderV);
+      cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+      cell.y = renderV >= 0 ? t.counts.posMaxHt + twSettings.contBarGap - cell.height : t.counts.posMaxHt + twSettings.contBarGap;
+      cell.convertedValueLabel = !vc ? "" : convertUnits(cell.key, vc.fromUnit, vc.toUnit, vc.scaleFactor);
+    }
+  } else {
+    cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+    cell.y = height * i;
+    const group = tw.legend?.group || tw.$id;
+    return { ref: t.ref, group, value: key, entry: { key, label: cell.label, fill: cell.fill } };
+  }
+}
+function setSurvivalCellProps(cell, tw, anno, value, s, t, self2, width, height, dx, dy, i) {
+  const key = tw.q?.mode == "continuous" ? anno.value : anno.key;
+  cell.key = key;
+  cell.label = tw.q?.mode == "continuous" ? tw.term.unit ? `${key} ${tw.term.unit}` : key : tw.term.values?.[key].label ? tw.term.values?.[key].label : "Exit code: " + key;
+  cell.fill = self2.config.settings.matrix.twSpecificSettings?.[tw.$id]?.[key]?.color || (key == 1 ? "#a1a3a6" : "#a3c88b");
+  cell.order = 0;
+  if (tw.q?.mode == "continuous") {
+    const twSpecificSettings = self2.config.settings.matrix.twSpecificSettings;
+    if (!twSpecificSettings[tw.$id]) twSpecificSettings[tw.$id] = {};
+    const twSettings = twSpecificSettings[tw.$id];
+    if (!twSettings.contBarH) twSettings.contBarH = s.barh;
+    if (!("gap" in twSettings)) twSettings.contBarGap = 4;
+    cell.exitCodeKey = tw.term.values?.[anno.key].label || "Exit code: " + anno.key;
+    cell.fill = self2.config.settings.matrix.twSpecificSettings?.[tw.$id]?.[anno.key]?.color || (anno.key == 1 ? "#a1a3a6" : "#a3c88b");
+    if (s.transpose) {
+      cell.height = t.scale(cell.key);
+      cell.x = twSettings.contBarGap;
+    } else {
+      const vc = cell.term.valueConversion;
+      let renderV = vc ? cell.key * vc.scaleFactor : cell.key;
+      if (tw.q.convert2ZScore) {
+        renderV = (renderV - t.mean) / t.std;
+        cell.zscoreLabel = ` (Z-score: ${renderV.toFixed(2)})`;
+      }
+      cell.label = tw.term.unit ? `${cell.key.toFixed(2)} ${tw.term.unit}` : cell.key.toFixed(2);
+      cell.height = renderV >= 0 ? t.scales.pos(renderV) : t.scales.neg(renderV);
+      cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+      cell.y = renderV >= 0 ? t.counts.posMaxHt + twSettings.contBarGap - cell.height : t.counts.posMaxHt + twSettings.contBarGap;
+      cell.convertedValueLabel = !vc ? "" : convertUnits(cell.key, vc.fromUnit, vc.toUnit, vc.scaleFactor);
+    }
+  } else {
+    const vc = cell.term.valueConversion;
+    cell.timeToEventKey = vc ? convertUnits(anno.value, vc.fromUnit, vc.toUnit, vc.scaleFactor) : anno.value.toFixed(2);
+    cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+    cell.y = height * i;
+    const group = tw.legend?.group || tw.$id;
+    return { ref: t.ref, group, value: key, entry: { key, label: cell.label, fill: cell.fill } };
+  }
+}
+function setCategoricalCellProps(cell, tw, anno, value, s, t, self2, width, height, dx, dy, i) {
+  const values = tw.term.values || {};
+  const key = anno.key;
+  cell.label = "label" in anno ? anno.label : values[key]?.label ? values[key].label : key;
+  cell.fill = self2.config.settings.matrix.twSpecificSettings?.[tw.$id]?.[key]?.color || anno.color || values[anno.key]?.color;
+  cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+  cell.y = height * i;
+  const group = tw.legend?.group || tw.$id;
+  return { ref: t.ref, group, value: anno.key, entry: { key, label: cell.label, fill: cell.fill } };
+}
+function setGeneVariantCellProps(cell, tw, anno, value, s, t, self2, width, height, dx, dy, i) {
+  if (tw.q?.type == "predefined-groupset" || tw.q?.type == "custom-groupset") {
+    cell.label = value;
+    const groupset = tw.q.type == "custom-groupset" ? tw.q.customset : tw.term.groupsetting.lst[tw.q.predefined_groupset_idx];
+    if (!groupset) throw "groupset not found";
+    const group = groupset.groups.find((group2) => group2.name == value);
+    if (!group) throw "group not found";
+    cell.fill = group.color;
+    cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+    cell.y = height * i;
+    return {
+      ref: t.ref,
+      group: tw.legend?.group || tw.$id,
+      value,
+      entry: { key: anno.key, label: cell.label, fill: cell.fill }
+    };
+  } else {
+    const values = anno.renderedValues || anno.filteredValues || anno.values || [anno.value];
+    const colorFromq = tw.q?.values && tw.q?.values[value.class]?.color;
+    cell.label = value.label || self2.mclass[value.class].label;
+    cell.fill = self2.getValueColor?.(value.value) || colorFromq || value.color || self2.mclass[value.class]?.color;
+    cell.class = value.class;
+    cell.value = value;
+    const colw = self2.dimensions.colw;
+    if (s.cellEncoding == "") {
+      cell.height = s.rowh / values.length;
+      cell.width = colw;
+      cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+      cell.y = height * i;
+    } else if (value.dt == dtsnvindel || value.dt == dtfusionrna || value.dt == dtsv) {
+      if (s.cellEncoding == "single") {
+        cell.height = s.rowh;
+        cell.width = colw;
+        cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+        cell.y = 0;
+      } else {
+        const divisor = 3;
+        cell.height = s.rowh / divisor;
+        cell.width = colw;
+        cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+        cell.y = height * 0.33333;
+        if (s.oncoPrintSNVindelCellBorder) {
+          cell.border = true;
+        }
+      }
+    } else if (value.dt == dtcnv || value.dt == dtgeneexpression) {
+      cell.height = s.rowh;
+      cell.width = colw;
+      cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+      cell.y = 0;
+    } else {
+      throw `cannot set cell props for dt='${value.dt}'`;
+    }
+    if (value.class == "Blank" || value.class == "WT") {
+      cell.label = `${self2.dt2label[value.dt]} ${cell.label}`;
+    }
+    const byDt = self2.state.termdbConfig.assayAvailability?.byDt;
+    const order = CNVkey2order(value.class);
+    if (value.dt == dtcnv) {
+      if (t.scales && value.class.startsWith("CNV_")) {
+        const {
+          /*maxLoss,*/
+          maxGain,
+          minLoss,
+          /*minGain,*/
+          absMax
+        } = t.scales;
+        value.scaledValue = value.value < 0 ? value.value / -absMax : value.value / absMax;
+        cell.fill = value.value < 0 ? t.scales.loss(value.scaledValue) : t.scales.gain(value.scaledValue);
+        return {
+          ref: t.ref,
+          group: "CNV",
+          value: value.class,
+          order: -1,
+          entry: {
+            key: value.class,
+            label: cell.label,
+            scale: value.class == "CNV_loss" ? t.scales.loss : t.scales.gain,
+            domain: t.domain ? t.domain : value.class == "CNV_loss" ? [0, -minLoss] : [0, maxGain],
+            colors: t.range,
+            scales: value.dt == 4 && t.scales,
+            minLabel: 0,
+            maxLabel: value.class == "CNV_loss" ? minLoss : maxGain,
+            order,
+            dt: value.dt,
+            origin: value.origin
+          }
+        };
+      } else {
+        const group = "CNV";
+        return {
+          ref: t.ref,
+          group,
+          value: value.class,
+          order: -1,
+          entry: { key: value.class, label: cell.label, fill: cell.fill, order, dt: value.dt, origin: value.origin }
+        };
+      }
+    } else if (value.dt == dtfusionrna && byDt?.[dtfusionrna]) {
+      const group = "Fusion RNA";
+      return {
+        ref: t.ref,
+        group,
+        value: value.class,
+        order: -1,
+        entry: { key: value.class, label: cell.label, fill: cell.fill, order, dt: value.dt, origin: value.origin }
+      };
+    } else if (value.dt == dtsv && byDt?.[dtsv]) {
+      const group = "Structural Variation";
+      return {
+        ref: t.ref,
+        group,
+        value: value.class,
+        order: -1,
+        entry: { key: value.class, label: cell.label, fill: cell.fill, order, dt: value.dt, origin: value.origin }
+      };
+    } else if (value.dt == dtgeneexpression) {
+      return {
+        ref: t.ref,
+        group: self2.config.settings.hierCluster?.termGroupName || "Gene Expression",
+        value: value.class,
+        order: -1,
+        entry: {
+          key: value.class,
+          label: "",
+          scale: self2.geneExpValues.scale,
+          domain: [0, 0.5, 1],
+          minLabel: self2.geneExpValues.min,
+          maxLabel: self2.geneExpValues.max,
+          order,
+          dt: value.dt,
+          origin: value.origin
+        }
+      };
+    } else {
+      const controlLabels = self2.settings.matrix.controlLabels;
+      const group = tw.legend?.group || (value.origin ? `${value.origin[0].toUpperCase() + value.origin.slice(1)} ${controlLabels.Mutations}` : controlLabels.Mutations);
+      return {
+        ref: t.ref,
+        group,
+        value: value.class,
+        order: -2,
+        entry: { key: value.class, label: cell.label, fill: cell.fill, order, dt: value.dt, origin: value.origin }
+      };
+    }
+  }
+}
+function setHierClusterCellProps(cell, tw, anno, value, s, t, self2, width, height, dx, dy, i) {
+  const values = anno.renderedValues || anno.filteredValues || anno.values || [anno.value];
+  cell.label = value.value;
+  cell.fill = self2.getValueColor?.(value.value);
+  cell.value = value;
+  const colw = self2.dimensions.colw;
+  cell.height = s.clusterRowh;
+  cell.width = colw;
+  cell.x = cell.totalIndex * dx + cell.grpIndex * s.colgspace;
+  cell.y = height * i;
+  const hierCluster = self2.config.settings.hierCluster;
+  let groupName;
+  if (hierCluster?.termGroupName) {
+    groupName = hierCluster.termGroupName;
+  } else if (tw.term.type == "geneExpression") {
+    groupName = "Gene Expression";
+    const unit = self2.app.vocabApi.termdbConfig.queries?.geneExpression?.unit;
+    if (hierCluster?.zScoreTransformation) groupName += " (Z-score)";
+    else if (unit) groupName += ` (${unit})`;
+  } else if (tw.term.type == "metaboliteIntensity") {
+    groupName = "Intensity";
+  } else if (tw.term.type == "proteomeAbundance") {
+    groupName = "Protein Abundance";
+  } else {
+    groupName = "Heatmap color scale";
+  }
+  return {
+    ref: t.ref,
+    group: groupName,
+    order: -1,
+    entry: {
+      label: "",
+      scale: self2.hierClusterValues.scale,
+      domain: colorScaleMap[self2.settings.hierCluster.colorScale].domain,
+      minLabel: self2.hierClusterValues.min,
+      maxLabel: self2.hierClusterValues.max,
+      order: 0,
+      dt: value.dt
+    }
+  };
+}
+function getEmptyCell(cellTemplate, s, d) {
+  const cell = Object.assign({}, cellTemplate);
+  cell.fill = s.cellbg;
+  cell.height = s.rowh;
+  cell.width = d.colw;
+  cell.x = cell.totalIndex * d.dx + cell.grpIndex * s.colgspace;
+  cell.y = 0;
+  return cell;
+}
+var setCellProps = {
+  // some of these have been replaced by addOns{setCellProps} in matrix.xtw.ts,
+  // but leaving here for now since non-classed tw's may still use these
+  categorical: setCategoricalCellProps,
+  condition: setCategoricalCellProps,
+  integer: setNumericCellProps,
+  float: setNumericCellProps,
+  survival: setSurvivalCellProps,
+  geneVariant: setGeneVariantCellProps,
+  hierCluster: setHierClusterCellProps,
+  [TermTypes.GENE_EXPRESSION]: setNumericCellProps,
+  [TermTypes.METABOLITE_INTENSITY]: setNumericCellProps,
+  [TermTypes.PROTEOME_ABUNDANCE]: setNumericCellProps
+  //termCollection: setTermCollectionCellProps
+};
+var maySetEmptyCell = {
+  geneVariant: setVariantEmptyCell,
+  integer: setNumericEmptyCell,
+  float: setNumericEmptyCell,
+  categorical: setDefaultEmptyCell,
+  condition: setDefaultEmptyCell,
+  survival: setNumericEmptyCell,
+  [TermTypes.GENE_EXPRESSION]: setNumericEmptyCell,
+  [TermTypes.METABOLITE_INTENSITY]: setNumericEmptyCell,
+  [TermTypes.PROTEOME_ABUNDANCE]: setNumericEmptyCell
+};
+function setVariantEmptyCell(siblingCells, cellTemplate, s, d) {
+  if (siblingCells.find((c) => c.value.dt == dtcnv)) return;
+  const cell = Object.assign({}, cellTemplate);
+  cell.fill = s.cellbg;
+  cell.height = s.rowh;
+  cell.width = d.colw;
+  cell.x = cell.totalIndex * d.dx + cell.grpIndex * s.colgspace;
+  cell.y = 0;
+  return cell;
+}
+function setNumericEmptyCell(siblingCells, cellTemplate, s, d) {
+  const q = cellTemplate.tw.q;
+  if (q.mode != "continuous") {
+    if (siblingCells.length) return;
+    setDefaultEmptyCell(siblingCells, cellTemplate, s, d);
+  } else {
+    if (q?.mode != "continuous") return;
+    const twSpecificSettings = self.config.settings.matrix.twSpecificSettings;
+    const twSettings = twSpecificSettings[cellTemplate.$id];
+    const h = twSettings ? twSettings.contBarH + 2 * contBarGap : s.rowh;
+    if (cellTemplate.height >= h) return;
+    const cell = Object.assign({}, cellTemplate);
+    cell.fill = s.cellbg;
+    cell.height = h || s.rowh;
+    cell.width = d.colw;
+    cell.x = cell.totalIndex * d.dx + cell.grpIndex * s.colgspace;
+    cell.y = 0;
+    return cell;
+  }
+}
+function setDefaultEmptyCell(siblingCells, cellTemplate, s, d) {
+  if (siblingCells.length) return;
+  const cell = Object.assign({}, cellTemplate);
+  cell.fill = s.cellbg;
+  cell.height = s.rowh;
+  cell.width = d.colw;
+  cell.x = cell.totalIndex * d.dx + cell.grpIndex * s.colgspace;
+  cell.y = 0;
+  return cell;
+}
+
+export {
+  setGeneVariantCellProps,
+  setHierClusterCellProps,
+  getEmptyCell,
+  setCellProps,
+  maySetEmptyCell
+};
+//# sourceMappingURL=chunk-GPOECA3V.js.map