@sjcrh/proteinpaint-client 2.198.0 → 2.200.0

package/dist/chunk-RKO6BL5N.js

@@ -1,446 +0,0 @@
-import {
-  schemeCategory20
-} from "./chunk-V2OJLJSK.js";
-import {
-  isNumericTerm
-} from "./chunk-I6WR4CG7.js";
-import {
-  dtcnv,
-  dtsnvindel
-} from "./chunk-2X6W4E3W.js";
-import {
-  category10_default
-} from "./chunk-3XVVN66M.js";
-import {
-  linear,
-  ordinal
-} from "./chunk-NSTL4MY2.js";
-import {
-  __export
-} from "./chunk-HFNDKYVF.js";
-
-// plots/matrix/matrix.legend.js
-var matrix_legend_exports = {};
-__export(matrix_legend_exports, {
-  CNVkey2order: () => CNVkey2order,
-  getLegendData: () => getLegendData,
-  getLegendItemText: () => getLegendItemText
-});
-function getLegendData(legendGroups, refs, self) {
-  const s = this.settings.matrix;
-  const legendData = [];
-  const dvt = this.config.divideBy || {};
-  const dvtId = dvt && "id" in dvt ? dvt.id : dvt.name;
-  for (const $id in legendGroups) {
-    const legend = legendGroups[$id];
-    if ($id == "Consequences") {
-      for (const f of this.config.legendValueFilter.lst) {
-        if (f.tvs.term.type !== "geneVariant") continue;
-        if (f.legendGrpName != $id) continue;
-        if (f.tvs.legendFilterType == "geneVariant_soft" && f.filteredOutCats.length == 0) {
-          continue;
-        }
-        for (const v of f.tvs.values) {
-          for (const key of v.mclasslst) {
-            const legendk = v.origin ? v.origin + key : key;
-            legend.values[legendk] = {
-              key,
-              dt: v.dt,
-              origin: v.origin,
-              label: v.label || self.mclass[key].label,
-              fill: v.color || self.mclass[key]?.color,
-              order: CNVkey2order(key),
-              crossedOut: f.tvs.legendFilterType == "geneVariant_hard" ? true : false,
-              greyedOut: f.tvs.legendFilterType == "geneVariant_soft" ? true : false
-            };
-          }
-        }
-      }
-      const keys2 = Object.keys(legend.values);
-      if (!keys2.length) continue;
-      legendData.unshift({
-        name: "Consequences",
-        order: legend.order,
-        $id: legend.$id,
-        dt: legend.dt,
-        origin: legend.origin,
-        items: keys2.map((key, i) => {
-          const item = legend.values[key];
-          const count = item.samples?.size;
-          return {
-            termid: "Consequences",
-            key: item.key,
-            text: this.getLegendItemText(item, count, {}, s),
-            color: item.fill,
-            order: i,
-            border: "1px solid #ccc",
-            count,
-            isLegendItem: true,
-            dt: item.dt,
-            crossedOut: item.crossedOut,
-            greyedOut: item.greyedOut,
-            origin: item.origin
-          };
-        })
-      });
-      legendData[0].items.sort((a, b) => a.text < b.text ? -1 : 1);
-      continue;
-    }
-    const t = $id == dvtId ? { tw: dvt } : this.termOrder.find((t2) => t2.tw.$id == $id || t2.tw.legend?.group == $id) || {
-      tw: { term: { id: $id, name: $id, type: $id === "CNV" ? "geneVariant" : "" } }
-    };
-    for (const f of this.config.legendValueFilter.lst) {
-      const name = t.tw.legend?.group || t.tw.label || t.tw.term.name;
-      if (f.legendGrpName != $id && f.legendGrpName != name && f.tvs.term.name != name) continue;
-      if (f.tvs.term.type == "geneVariant") {
-        for (const v of f.tvs.values) {
-          if (legend.dt && !legend.dt.includes(v.dt)) legend.dt.push(v.dt);
-          if (f.tvs.legendFilterType == "geneVariant_soft" && f.filteredOutCats.length == 0) {
-            continue;
-          }
-          for (const key of v.mclasslst) {
-            const legendk = v.origin ? v.origin + key : key;
-            legend.values[legendk] = {
-              key,
-              dt: v.dt,
-              origin: v.origin,
-              label: v.label || self.mclass[key]?.label || "Gain and loss",
-              fill: v.color || self.mclass[key]?.color,
-              order: CNVkey2order(key),
-              crossedOut: f.tvs.legendFilterType == "geneVariant_hard" ? true : false,
-              greyedOut: f.tvs.legendFilterType == "geneVariant_soft" ? true : false
-            };
-          }
-        }
-      } else {
-        if (isNumericTerm(f.tvs.term)) {
-          if (t.ref?.bins) {
-            for (const v of f.tvs.ranges) {
-              const termValues = t.ref.bins;
-              legend.values[v.name] = {
-                key: v.name,
-                label: termValues?.find((vl) => vl.name == v.name)?.name || v.name,
-                fill: termValues?.find((vl) => vl.name == v.name)?.color,
-                crossedOut: true
-              };
-            }
-          }
-        } else if (f.tvs.term.type == "survival") {
-          for (const v of f.tvs.values) {
-            const termValues = t.tw.term.values;
-            legend.values[v.key] = {
-              key: v.key,
-              label: termValues?.[v.key]?.label || "Exit code: " + v.key,
-              fill: v.key == 1 ? "#ff7f0e" : "#1f77b4",
-              crossedOut: true
-            };
-          }
-        } else {
-          for (const v of f.tvs.values) {
-            const termValues = t.tw.term.values;
-            legend.values[v.key] = {
-              key: v.key,
-              label: termValues?.[v.key]?.label || v.key,
-              fill: termValues?.[v.key]?.color,
-              crossedOut: true
-            };
-          }
-        }
-      }
-    }
-    const keys = Object.keys(legend.values).sort();
-    const hasScale = Object.values(legend.values).find((v) => v.scale);
-    if (hasScale) {
-      if (legend === legendGroups?.CNV) {
-        const gain = legend.values["CNV_amp"];
-        const loss = legend.values["CNV_loss"];
-        if (gain?.scale && loss?.scale) {
-          const colors = loss.scales?.legend.range;
-          const domain = loss.scales?.legend.domain;
-          const setLegendAttr = (item) => {
-            return {
-              $id,
-              domain: item.scales.legend.domain,
-              key: item.key,
-              isLegendItem: true,
-              minLabel: domain[0],
-              //item.minLoss, // item.maxLabel,
-              maxLabel: domain.slice(-1)[0],
-              //item.maxGain, // item.maxLabel,
-              scale: item.scale,
-              termid: "CNV"
-            };
-          };
-          const numericInputs = {
-            cutoffMode: s.cnvValues.cutoffMode,
-            defaultPercentile: s.cnvValues.defaultPercentile,
-            percentile: s.cnvValues.percentile,
-            callback: async (obj) => {
-              const cValues = self.config.settings.matrix.cnvValues;
-              if (obj.cutoffMode == "fixed") {
-                if (cValues.min == null) cValues.min = domain[0];
-                if (cValues.max == null) cValues.max = domain[domain.length - 1];
-                if (obj.min != cValues.min) obj.max = Math.abs(obj.min);
-                else obj.min = -obj.max;
-              }
-              self.config.settings.matrix.cnvValues = {
-                defaultPercentile: self.config.settings.matrix.cnvValues.defaultPercentile,
-                cutoffMode: obj.cutoffMode,
-                min: obj.min,
-                max: obj.max,
-                percentile: obj.percentile
-              };
-              await self.app.dispatch({
-                type: "plot_edit",
-                id: self.opts.id,
-                config: self.config
-              });
-            }
-          };
-          legend.values.CNV_gain_loss = {
-            key: $id,
-            label: "Gain and Loss",
-            dt: dtcnv,
-            order: -1,
-            domain,
-            name: "CNV gain/loss",
-            scale: linear().domain(domain).range(colors),
-            scales: loss.scales,
-            //Prevent the colors and domain recalculating below
-            minLabel: domain[0],
-            //loss.maxLabel,
-            maxLabel: domain.slice(-1)[0],
-            labels: { left: "Loss", right: "Gain" },
-            parents: [Object.assign(setLegendAttr(loss), loss), Object.assign(setLegendAttr(gain), gain)],
-            samples: /* @__PURE__ */ new Set([...gain.samples, ...loss.samples]),
-            numericInputs
-          };
-          delete legend.values[gain.key];
-          delete legend.values[loss.key];
-          keys.splice(keys.indexOf(gain.key), 1);
-          keys.splice(keys.indexOf(loss.key), 1);
-          keys.push("CNV_gain_loss");
-        }
-      }
-      const legendGrpLabelMaxChars = s.legendGrpLabelMaxChars || 26;
-      legendData.push({
-        name: $id.length < legendGrpLabelMaxChars ? $id : $id.slice(0, legendGrpLabelMaxChars) + "...",
-        //name:$id,
-        order: legend.order,
-        $id: legend.$id,
-        dt: legend.dt,
-        origin: legend.origin,
-        hasScale,
-        items: keys.map((key, i) => {
-          const item = legend.values[key];
-          const count = item.samples?.size;
-          if (item.scale) {
-            const colors = item.scales?.legend?.range || getColors(item);
-            const domain = item.scales?.legend?.domain || setColorScaleDomain(item.minLabel, item.maxLabel, item.domain, colors);
-            const opts = {
-              termid: $id,
-              key: item.key,
-              text: this.getLegendItemText(item, count, t, s),
-              width: 100,
-              scale: item.scale,
-              colors,
-              domain,
-              order: "order" in item ? item.order : i,
-              count,
-              isLegendItem: true,
-              dt: item.dt,
-              crossedOut: item.crossedOut,
-              greyedOut: item.greyedOut,
-              origin: item.origin,
-              parents: item.parents,
-              labels: item.labels
-            };
-            if (item.numericInputs) {
-              opts.numericInputs = item.numericInputs;
-            }
-            return opts;
-          } else {
-            return {
-              termid: $id,
-              key: item.key,
-              text: this.getLegendItemText(item, count, t, s),
-              color: item.fill || this.colorScaleByTermId[$id](key),
-              order: "order" in item ? item.order : i,
-              count,
-              isLegendItem: true,
-              dt: item.dt,
-              crossedOut: item.crossedOut,
-              greyedOut: item.greyedOut,
-              origin: item.origin
-            };
-          }
-        })
-      });
-    } else {
-      const grp = $id;
-      const term = t.tw.term;
-      const ref = legend.ref;
-      if (ref.bins)
-        keys.sort((a, b) => ref.bins.findIndex((bin) => bin.name === a) - ref.bins.findIndex((bin) => bin.name === b));
-      else if (ref.keyOrder) keys.sort((a, b) => ref.keyOrder.indexOf(a) - ref.keyOrder.indexOf(b));
-      if (!this.colorScaleByTermId[grp])
-        this.colorScaleByTermId[grp] = keys.length < 11 ? ordinal(category10_default) : ordinal(schemeCategory20);
-      const name = t.tw.legend?.group || t.tw.label || term.name;
-      const legendGrpLabelMaxChars = s.legendGrpLabelMaxChars || 26;
-      legendData.push({
-        name: name.length < legendGrpLabelMaxChars ? name : name.slice(0, legendGrpLabelMaxChars) + "...",
-        order: legend.order,
-        $id: legend.$id,
-        dt: legend.dt,
-        origin: legend.origin,
-        items: keys.map((key, i) => {
-          const item = legend.values[key];
-          const count = item.samples?.size;
-          return {
-            $id,
-            termid: term.id || term.name,
-            key: item.key,
-            text: this.getLegendItemText(item, count, t, s),
-            color: t.scale || item.fill || this.colorScaleByTermId[grp](key),
-            order: "order" in item ? item.order : i,
-            count,
-            isExcluded: item.isExcluded,
-            //onClickCallback: this.handleLegendItemClick,
-            isLegendItem: true,
-            dt: item.dt,
-            crossedOut: item.crossedOut,
-            greyedOut: item.greyedOut,
-            origin: item.origin
-          };
-        })
-      });
-    }
-  }
-  for (const grpFilter of self.config.legendGrpFilter.lst) {
-    if (grpFilter.dt.length == 1 && grpFilter.dt[0] == 4 && !legendData.filter((l) => l.dt)?.find((l) => l.dt.length == 1 && l.dt[0] == 4)) {
-      legendData.push({
-        name: "CNV",
-        dt: grpFilter.dt,
-        origin: grpFilter.origin,
-        crossedOut: true,
-        items: grpFilter.filteredOutCats.map((fc) => {
-          return {
-            dt: 4,
-            termid: "CNV",
-            origin: grpFilter.origin,
-            key: fc,
-            text: self.mclass[fc].label,
-            color: self.mclass[fc]?.color,
-            isLegendItem: true
-          };
-        })
-      });
-    } else if (grpFilter.dt.includes(dtsnvindel)) {
-      const controlLabels = self.settings.matrix.controlLabels;
-      const groupName = grpFilter.origin ? `${grpFilter.origin[0].toUpperCase() + grpFilter.origin.slice(1)} ${controlLabels.Mutations}` : controlLabels.Mutations;
-      if (!legendData.filter((l) => l.dt)?.find((l) => l.dt.includes(dtsnvindel) && l.origin == grpFilter.origin)) {
-        legendData.push({
-          name: groupName,
-          dt: grpFilter.dt,
-          origin: grpFilter.origin,
-          crossedOut: true,
-          items: grpFilter.filteredOutCats.map((fc) => {
-            return {
-              dt: self.mclass[fc].dt,
-              origin: grpFilter.origin,
-              termid: groupName,
-              key: fc,
-              text: self.mclass[fc].label,
-              color: self.mclass[fc]?.color,
-              isLegendItem: true
-            };
-          })
-        });
-      }
-    } else if (grpFilter.dt.length == 1 && grpFilter.dt[0] == 2 && !legendData.filter((l) => l.dt)?.find((l) => l.dt.length == 1 && l.dt[0] == 2)) {
-      legendData.push({
-        name: "Fusion RNA",
-        dt: grpFilter.dt,
-        origin: grpFilter.origin,
-        crossedOut: true,
-        items: grpFilter.filteredOutCats.map((fc) => {
-          return {
-            dt: 2,
-            origin: grpFilter.origin,
-            termid: "Fusion RNA",
-            key: fc,
-            text: self.mclass[fc].label,
-            color: self.mclass[fc]?.color,
-            isLegendItem: true
-          };
-        })
-      });
-    } else if (grpFilter.dt.length == 1 && grpFilter.dt[0] == 5 && !legendData.filter((l) => l.dt)?.find((l) => l.dt.length == 1 && l.dt[0] == 5)) {
-      legendData.push({
-        name: "Structural Variation",
-        dt: grpFilter.dt,
-        origin: grpFilter.origin,
-        crossedOut: true,
-        items: grpFilter.filteredOutCats.map((fc) => {
-          return {
-            dt: 5,
-            origin: grpFilter.origin,
-            termid: "Structural Variation",
-            key: fc,
-            text: self.mclass[fc].label,
-            color: self.mclass[fc]?.color,
-            isLegendItem: true
-          };
-        })
-      });
-    }
-  }
-  for (const itemsGrp of legendData) {
-    itemsGrp.items.sort((a, b) => {
-      const getStatusOrder = (item) => {
-        if (!item.greyedOut && !item.crossedOut) return 0;
-        if (item.greyedOut && !item.crossedOut) return 1;
-        if (item.crossedOut) return 2;
-        return 3;
-      };
-      return getStatusOrder(a) - getStatusOrder(b);
-    });
-  }
-  return legendData.sort(
-    (a, b) => a.crossedOut && b.crossedOut ? 0 : a.crossedOut ? 1 : b.crossedOut ? -1 : a.order && b.order ? a.order - b.order : a.order ? -1 : b.order ? 1 : 0
-  );
-}
-function getLegendItemText(item, count, t, s) {
-  if (item.crossedOut || item.greyedOut) {
-    return item.label;
-  }
-  let text = item.label;
-  const notes = [count];
-  if (item.isExcluded) notes.push("hidden");
-  if (t?.tw?.term?.type == "geneVariant" && s.geneVariantCountSamplesSkipMclass.includes(item.key))
-    notes.push("not counted");
-  if (!notes.length) return text;
-  return text += ` (${notes.join(", ")})`;
-}
-function setColorScaleDomain(min, max, domain, colors) {
-  if (domain[0] === min && domain[domain.length - 1] === max) return domain;
-  const step = (max - min) / (colors.length - 1);
-  return colors.map((_, i) => {
-    if (i === (colors.length - 1) / 2 && min < 0 && max > 0) return 0;
-    return min + step * i;
-  });
-}
-function getColors(item) {
-  return item.domain?.map((c) => item.scale(c)) || item.scale.range();
-}
-function CNVkey2order(key) {
-  return key == "CNV_homozygous_deletion" ? -5 : key == "CNV_amplification" ? -4 : key == "CNV_loss" ? -3 : key == "CNV_amp" ? -2 : key == "CNV_loh" ? -1 : 0;
-}
-
-export {
-  getLegendData,
-  getLegendItemText,
-  CNVkey2order,
-  matrix_legend_exports
-};
-//# sourceMappingURL=chunk-RKO6BL5N.js.map

package/dist/chunk-T25QNZHB.js

@@ -1,254 +0,0 @@
-import {
-  getMclassSorter,
-  getSampleGroupSorter,
-  getSampleSorter,
-  getTermSorter
-} from "./chunk-OXVLWQ6M.js";
-import {
-  sample_match_termvaluesetting
-} from "./chunk-7IYJZZQI.js";
-import {
-  dtcnv,
-  dtfusionrna,
-  dtgeneexpression,
-  dtsnvindel
-} from "./chunk-2X6W4E3W.js";
-import {
-  __export
-} from "./chunk-HFNDKYVF.js";
-
-// plots/matrix/matrix.groups.js
-var matrix_groups_exports = {};
-__export(matrix_groups_exports, {
-  classifyValues: () => classifyValues,
-  getSampleGroups: () => getSampleGroups,
-  getSampleOrder: () => getSampleOrder,
-  getTermOrder: () => getTermOrder,
-  stackSiblingCellsByClass: () => stackSiblingCellsByClass
-});
-function getTermOrder(data) {
-  const s = this.settings.matrix;
-  this.termSorter = getTermSorter(this, s);
-  const termOrder = [];
-  let totalIndex = 0, visibleGrpIndex = 0, numClusterTerms = 0;
-  this.mclassSorter = getMclassSorter(this);
-  for (const [grpIndex, grp] of this.termGroups.entries()) {
-    const lst = [];
-    for (const [index, tw] of grp.lst.entries()) {
-      const counts = { samples: 0, hits: 0 };
-      const countedSamples = /* @__PURE__ */ new Set();
-      for (const sd of data.lst) {
-        if (countedSamples.has(sd.sample)) continue;
-        countedSamples.add(sd.sample);
-        const anno = sd[tw.$id];
-        if (anno) {
-          const { filteredValues, countedValues, renderedValues } = this.classifyValues(anno, tw, grp, s, sd);
-          anno.filteredValues = filteredValues;
-          anno.countedValues = countedValues;
-          anno.renderedValues = renderedValues;
-          if (anno.countedValues?.length) {
-            const v = tw.term.values?.[anno.value];
-            if (v?.uncountable) continue;
-            counts.samples += 1;
-            counts.hits += anno.countedValues.length;
-            if (tw.q?.mode == "continuous") {
-              const v2 = anno.value;
-              if (!("minval" in counts) || counts.minval > v2) counts.minval = v2;
-              if (!("maxval" in counts) || counts.maxval < v2) counts.maxval = v2;
-            }
-          }
-        }
-      }
-      if (grp.type != "hierCluster" || counts.samples) lst.push({ tw, counts, index });
-      if (grp.type == "hierCluster") numClusterTerms++;
-    }
-    const termSorter = grp.sortTermsBy || grp.type == "hierCluster" ? getTermSorter(this, s, grp) : this.termSorter;
-    const processedLst = lst.filter((t) => {
-      if ("minNumSamples" in t.tw) return t.tw.minNumSamples <= t.counts.samples;
-      if (!grp.settings) return true;
-      return !("minNumSamples" in grp.settings) || t.counts.samples >= grp.settings.minNumSamples;
-    }).sort(termSorter);
-    if (!processedLst.length) continue;
-    for (const [index, t] of processedLst.entries()) {
-      const { tw, counts } = t;
-      const ref = data.refs.byTermId[t.tw.$id] || {};
-      termOrder.push({
-        grp,
-        grpIndex,
-        visibleGrpIndex,
-        tw,
-        index,
-        // rendered index
-        lstIndex: t.index,
-        // as-listed index, before applying term filters
-        processedLst,
-        prevGrpTotalIndex: totalIndex,
-        totalIndex: totalIndex + index,
-        ref,
-        allCounts: counts
-        // note: term label will be assigned after sample counts are known
-        // label: t.tw.label || t.tw.term.name,
-      });
-    }
-    totalIndex += processedLst.length;
-    visibleGrpIndex += 1;
-  }
-  this.numTerms = termOrder.length;
-  this.numClusterTerms = numClusterTerms;
-  return termOrder;
-}
-function getSampleGroups(data) {
-  const s = this.settings.matrix;
-  const defaultSampleGrp = {
-    id: this.config.divideBy?.$id,
-    name: this.config.divideBy ? "Not annotated" : "",
-    lst: []
-  };
-  const sampleGroups = /* @__PURE__ */ new Map();
-  const term = this.config.divideBy?.term || {};
-  const $id = this.config.divideBy?.$id || "-";
-  const exclude = this.config.divideBy?.exclude || [];
-  const values = term.values || {};
-  const ref = data.refs.byTermId[$id] || {};
-  for (const row of data.lst) {
-    if ($id in row) {
-      const key = row[$id].key;
-      const name = key in values && values[key].label ? values[key].label : key;
-      if (!sampleGroups.has(key)) {
-        const grp = {
-          name: `${name}`,
-          // convert to a string
-          id: key,
-          lst: [],
-          tw: this.config.divideBy,
-          legendGroups: {},
-          isExcluded: exclude.includes(key)
-        };
-        if (ref.bins && s.sortSampleGrpsBy == "name") grp.order = ref.bins.findIndex((bin) => bin.name == key);
-        else delete grp.order;
-        sampleGroups.set(key, grp);
-      }
-      sampleGroups.get(key).lst.push(row);
-    } else {
-      defaultSampleGrp.lst.push(row);
-    }
-  }
-  const sampleGrpsArr = [...sampleGroups.values()];
-  const n = sampleGroups.size;
-  if (n > 100 && sampleGrpsArr.filter((sg) => sg.lst.length < 3).length > 0.8 * n) {
-    const l = s.controlLabels;
-    throw `Did not group ${l.samples} by "${term.name}": too many ${l.sample} groups (${n}), with the majority of groups having <= 2 ${l.samples} per group.`;
-  }
-  if (defaultSampleGrp.lst.length && !sampleGroups.size) {
-    sampleGroups.set(void 0, defaultSampleGrp);
-    sampleGrpsArr.push(...sampleGroups.values());
-  }
-  this.asListedSampleOrder = [];
-  for (const grp of sampleGrpsArr) {
-    this.asListedSampleOrder.push(...grp.lst.map((s2) => s2.sample));
-  }
-  const selectedDictTerms = this.termOrder.filter((t) => t.tw.sortSamples && t.tw.term.type != "geneVariant");
-  const noGrpSampleSorter = getSampleSorter(this, s, data.lst, {
-    skipSorter: (p, tw) => !p.types?.includes("geneVariant") && selectedDictTerms.find((t) => t.tw.$id === tw.$id)
-  });
-  const noGrpSampleOrder = data.lst.sort(noGrpSampleSorter);
-  const allowedSamples = noGrpSampleOrder.slice(0, s.maxSample);
-  const dataFilter = (d) => allowedSamples.includes(d);
-  const hitsPerSample = (t, c) => t + (typeof c == "object" && c.countedValues?.length ? 1 : 0);
-  const countHits = (total, d) => total + (Object.values(d).reduce(hitsPerSample, 0) ? 1 : 0);
-  const grpLstSampleSorter = getSampleSorter(this, s, data.lst);
-  for (const grp of sampleGrpsArr) {
-    grp.lst = grp.lst.filter(dataFilter);
-    grp.totalCountedValues = grp.lst.reduce(countHits, 0);
-    grp.lst.sort(grpLstSampleSorter);
-  }
-  const sampleGrpSorter = getSampleGroupSorter(this);
-  return sampleGrpsArr.sort(sampleGrpSorter);
-}
-function getSampleOrder(data) {
-  const s = this.settings.matrix;
-  this.visibleSampleGrps = /* @__PURE__ */ new Set();
-  const sampleOrder = [];
-  let total = 0, numHiddenGrps = 0;
-  for (const [grpIndex, grp] of this.sampleGroups.entries()) {
-    if (!grp.lst.length) continue;
-    if (grp.isExcluded) numHiddenGrps++;
-    let processedLst = grp.lst;
-    for (const [index, row] of processedLst.entries()) {
-      sampleOrder.push({
-        grp,
-        grpIndex: grpIndex - numHiddenGrps,
-        // : this.sampleGroups.length,
-        row,
-        index,
-        prevGrpTotalIndex: total,
-        totalIndex: total + index,
-        totalHtAdjustments: 0,
-        // may be required when transposed???
-        grpTotals: { htAdjustment: 0 },
-        // may be required when transposed???
-        processedLst
-      });
-    }
-    if (!grp.isExcluded) total += processedLst.length;
-    this.visibleSampleGrps.add(grp);
-  }
-  this.unfilteredSampleOrder = sampleOrder;
-  return sampleOrder.filter((so) => !so.grp.isExcluded);
-}
-function classifyValues(anno, tw, grp, s, sample) {
-  const values = "value" in anno ? [anno.value] : anno.values;
-  if (!values) return { filteredValues: null, countedValues: null, renderedValues: null };
-  const isSpecific = [tw.valueFilter || grp.valueFilter].filter((v) => v && true);
-  if (isSpecific.length && isSpecific[0].type !== "tvs" && isSpecific[0].type !== "tvslst")
-    throw `unknown matrix value filter type='${isSpecific.type}'`;
-  let filteredValues = !isSpecific.length ? values : values.filter((v) => sample_match_termvaluesetting(v, isSpecific[0], tw.term, sample));
-  const renderedValues = [];
-  if (tw.term.type == "geneVariant" && tw.q?.type == "values") {
-    filteredValues.sort(this.mclassSorter);
-    if (s.cellEncoding == "") renderedValues.push(...filteredValues);
-    else {
-      const sortedFilteredValues = [];
-      for (const dt of [dtcnv, dtsnvindel, dtfusionrna, dtgeneexpression]) {
-        const v = dt == dtgeneexpression ? filteredValues.find((v2) => v2.dt === dt) : filteredValues.find((v2) => v2.dt === dt && v2.class !== "WT" && v2.class !== "Blank");
-        if (v) renderedValues.push(v);
-        const oneDtV = filteredValues.filter((v2) => v2.dt === dt);
-        sortedFilteredValues.push(...oneDtV);
-      }
-      filteredValues = sortedFilteredValues;
-    }
-  } else {
-    renderedValues.push(...filteredValues);
-  }
-  return {
-    filteredValues,
-    countedValues: filteredValues.filter((v) => {
-      if (tw.term.type == "geneVariant") {
-        if (tw.q?.type == "predefined-groupset" || tw.q?.type == "custom-groupset") {
-          const groupset = tw.q.type == "predefined-groupset" ? tw.term.groupsetting.lst[tw.q.predefined_groupset_idx] : tw.q.customset;
-          if (!groupset) throw "groupset not found";
-          const group = groupset.groups[0];
-          if (v != group.name) return false;
-        } else {
-          if (v.class == "WT" || v.class == "Blank" || s.geneVariantCountSamplesSkipMclass.includes(v.class))
-            return false;
-        }
-      }
-      return true;
-    }),
-    renderedValues
-  };
-}
-function stackSiblingCellsByClass(a, b) {
-  return a.class === b.class ? 0 : a.class === "Blank" ? 1 : b.class == "Blank" ? -1 : a.class < b.class ? -1 : 1;
-}
-
-export {
-  getTermOrder,
-  getSampleGroups,
-  getSampleOrder,
-  classifyValues,
-  stackSiblingCellsByClass,
-  matrix_groups_exports
-};
-//# sourceMappingURL=chunk-T25QNZHB.js.map