@sjcrh/proteinpaint-client 2.191.4 → 2.193.0

package/dist/chunk-5TJQ6633.js

@@ -0,0 +1,291 @@
+import {
+  getSortOptions
+} from "./chunk-CDUNE45Q.js";
+import {
+  defaultUiLabels,
+  fillTermWrapper
+} from "./chunk-L7VDSIM7.js";
+import {
+  copyMerge
+} from "./chunk-M3J4MINX.js";
+import {
+  isDictionaryType
+} from "./chunk-IVXCWCKS.js";
+import {
+  CNVClasses,
+  dtcnv,
+  mclass,
+  mutationClasses,
+  proteinChangingMutations,
+  synonymousMutations,
+  truncatingMutations
+} from "./chunk-7KRS7L4U.js";
+
+// plots/matrix/matrix.config.js
+async function getPlotConfig(opts = {}, app) {
+  const controlLabels = structuredClone(defaultUiLabels);
+  const devicePixelRatio = opts.devicePixelRatio || window.devicePixelRatio;
+  const config = {
+    // data configuration
+    termgroups: [],
+    samplegroups: [],
+    divideBy: null,
+    legendValueFilter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    legendGrpFilter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    filter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    // cnvCutoffs: {},
+    // rendering options
+    settings: {
+      matrix: {
+        svgCanvasSwitch: 1e3,
+        // the number of samples to trigger switching between svg and canvas
+        useMinPixelWidth: true,
+        // canvas may be hazy if false, but more accurately reflects column density
+        cellEncoding: "",
+        // can be "oncoprint" | "stacked" | "single"
+        margin: {
+          top: 10,
+          right: 5,
+          bottom: 20,
+          left: 50
+        },
+        // set any dataset-defined sample limits and sort priority, otherwise undefined
+        // put in settings, so that later may be overridden by a user
+        maxGenes: opts.settings?.maxGenes || 50,
+        maxSample: opts.settings?.maxSample || 1e3,
+        sampleNameFilter: "",
+        sortSamplesBy: "a",
+        sortPriority: void 0,
+        // will be filled-in
+        // sortByMutation: 'consequence', computed
+        // sortByCNV: true, computed
+        //sortOptions: getSortOptions(app.vocabApi.termdbConfig, controlLabels),
+        sortSampleGrpsBy: "name",
+        // 'hits' | 'name' | 'sampleCount'
+        sortSamplesTieBreakers: [{
+          $id: "sample",
+          sortSamples: {}
+          /*split: {char: '', index: 0}*/
+        }],
+        sortTermsBy: "sampleCount",
+        // or 'as listed'
+        // do not show number of samples at hiercluster gene row labels
+        samplecount4gene: opts.chartType == "hierCluster" ? "" : "abs",
+        //true, // 'abs' (default, previously true), 'pct', ''  (previously false)
+        geneVariantCountSamplesSkipMclass: [],
+        cellbg: "#ececec",
+        showGrid: "",
+        // false | 'pattern' | 'rect'
+        // whether to show these controls buttons
+        addMutationCNVButtons: false,
+        truncatingMutations,
+        proteinChangingMutations,
+        synonymousMutations,
+        mutationClasses,
+        CNVClasses,
+        gridStroke: "#fff",
+        outlineStroke: "#ccc",
+        beamStroke: "#f00",
+        colw: 0,
+        colwMin: 0.1 / devicePixelRatio,
+        colwMax: 16,
+        colspace: 1,
+        colgspace: 8,
+        colglabelpos: true,
+        collabelpos: "bottom",
+        collabelvisible: true,
+        collabelgap: 5,
+        collabelpad: 1,
+        collabelmaxchars: 32,
+        rowh: 18,
+        //use 0 to auto-compute row height, previous default=18,
+        rowhMin: 1,
+        rowhMax: 20,
+        rowspace: 1,
+        rowgspace: 8,
+        rowlabelpos: "left",
+        // | 'right'
+        rowlabelgap: 5,
+        rowlabelvisible: true,
+        rowlabelpad: 1,
+        rowlabelmaxchars: 32,
+        legendGrpLabelMaxChars: 26,
+        grpLabelFontSize: 12,
+        minLabelFontSize: 6,
+        maxLabelFontSize: 14,
+        transpose: false,
+        sampleLabelsToggle: opts.chartType === "hierCluster" ? "hide" : "auto",
+        // 'auto' | 'hide'
+        sampleLabelOffset: 120,
+        sampleGrpLabelOffset: 120,
+        sampleGrpLabelMaxChars: 32,
+        termLabelOffset: 80,
+        termGrpLabelOffset: 80,
+        termGrpLabelMaxChars: 32,
+        duration: 0,
+        zoomLevel: 1,
+        zoomCenterPct: 0,
+        zoomIndex: 0,
+        zoomGrpIndex: 0,
+        zoomMin: 0.5,
+        zoomIncrement: 0.1,
+        zoomStep: 1,
+        // renderedWMax should not be exposed as a user-input
+        // 60000 pixels is based on laptop and external monitor tests,
+        // when a canvas dataURL image in a zoomed-in matrix svg stops rendering
+        imgWMax: 6e4 / devicePixelRatio,
+        scrollHeight: 12,
+        controlLabels,
+        cnvUnit: "log2ratio",
+        ignoreCnvValues: false,
+        //will ignore numeric CNV values if true
+        barh: 32,
+        // default bar height for continuous terms,
+        // possible string entries:
+        // - "genesetEdit", for gene-centric embedders only like GDC OncoMatrix
+        // - may add other optional hints later
+        showHints: [],
+        genesetEditUiVersion: "",
+        // '' | 'withTabs'
+        // settings for a specific tw
+        twSpecificSettings: {},
+        oncoPrintSNVindelCellBorder: false,
+        // whether to show white cell border for SNVindel in oncoPrint mode
+        cnvValues: {
+          //Properties match the args for the ColorScales
+          //numericInput arg
+          cutoffMode: "percentile",
+          defaultPercentile: 99,
+          min: null,
+          max: null,
+          percentile: 99
+        }
+      }
+    }
+  };
+  const s = config.settings;
+  const fontsize = Math.max(s.matrix.rowh + s.matrix.rowspace - 3 * s.matrix.rowlabelpad, 12);
+  s.legend = {
+    ontop: false,
+    lineh: 25,
+    padx: 5,
+    padleft: 0,
+    //150,
+    padright: 20,
+    padbtm: 30,
+    fontsize,
+    iconh: fontsize - 2,
+    iconw: fontsize - 2,
+    hangleft: 1,
+    linesep: false
+  };
+  const overrides = app.vocabApi.termdbConfig.matrix || {};
+  copyMerge(config.settings.matrix, overrides.settings);
+  if (overrides.legendGrpFilter) config.legendGrpFilter = overrides.legendGrpFilter;
+  if (overrides.legendValueFilter) config.legendValueFilter = overrides.legendValueFilter;
+  if (overrides.filter) config.filter = overrides.filter;
+  if (opts.name) {
+    const data = await app.vocabApi.getMatrixByName(opts.name);
+    if (!data) throw "error from getMatrixByName()";
+    if (data.error) throw data.error;
+    copyMerge(config, data);
+  }
+  const os = opts?.settings?.matrix;
+  if (os) {
+    if ((os.sortSamplesBy == "custom" || os.sortSamplesBy == "asListed") && os.sortOptions?.custom.label == "against alteration type") {
+      os.sortSamplesBy = "a";
+    }
+    if (os.sortOptions) {
+      delete os.sortOptions.custom;
+      delete os.sortOptions.asListed;
+    }
+  }
+  copyMerge(config, opts);
+  const m = config.settings.matrix;
+  m.sortOptions = getSortOptions(app.vocabApi.termdbConfig, controlLabels, m);
+  m.duration = 0;
+  m.colw = 0;
+  if (m.sortSamplesBy != "asListed" && !m.sortOptions?.[m.sortSamplesBy]) m.sortSamplesBy = "a";
+  else if (["selectedTerms", "class", "dt", "hits"].includes(m.sortSamplesBy)) m.sortSamplesBy = "a";
+  if (m.samplecount4gene === true || m.samplecount4gene === 1) m.samplecount4gene = "abs";
+  if (window.location.hostname == "localhost") {
+    if (window.location.hash == "#canvas") m.svgCanvasSwitch = 0;
+  }
+  for (const grp of config.termgroups) {
+    const promises = [];
+    for (const tw of grp.lst) {
+      if (!tw.term?.type || isDictionaryType(tw.term.type)) {
+        if (!tw.id && tw.term.type != "samplelst" && tw.term.type != "termCollection") {
+          if (!tw.term.id) throw `missing tw.id and tw.term.id`;
+          tw.id = tw.term.id;
+        }
+        if (tw.term?.type != "samplelst" && tw.term?.type != "termCollection") delete tw.term;
+      }
+      promises.push(fillTermWrapper(tw, app.vocabApi));
+    }
+    grp.lst = await Promise.all(promises);
+  }
+  if (config.divideBy) config.divideBy = await fillTermWrapper(config.divideBy, app.vocabApi);
+  return config;
+}
+function setComputedConfig(config) {
+  const s = config.settings.matrix;
+  const allClasses = [...s.mutationClasses, ...s.CNVClasses];
+  s.filterByClass = { isAtomic: true };
+  for (const f of config.legendGrpFilter.lst) {
+    if (!f.dt) continue;
+    allClasses.filter((m) => f.dt.includes(mclass[m].dt)).forEach((key2) => {
+      s.filterByClass[key2] = "value";
+    });
+  }
+  for (const f of config.legendValueFilter.lst) {
+    if (!f.legendGrpName || f.tvs?.term?.type !== "geneVariant") continue;
+    if (f.tvs.values?.[0].mclasslst)
+      f.tvs.values[0].mclasslst.forEach((key2) => {
+        s.filterByClass[key2] = f.legendFilterType?.endsWith("_hard") ? "case" : "value";
+      });
+    else if (f.tvs.values)
+      f.tvs.values.forEach((v) => {
+        s.filterByClass[key] = "value";
+      });
+    else throw `unhandled tvs from legendValueFilter`;
+  }
+  s.hiddenVariants = Object.keys(s.filterByClass).filter((c) => c !== "isAtomic");
+  const hiddenCNVs = new Set(s.hiddenVariants.filter((key2) => mclass[key2]?.dt === dtcnv));
+  s.hiddenCNVs = [...hiddenCNVs];
+  s.showMatrixCNV = !hiddenCNVs.size ? "all" : hiddenCNVs.size == s.CNVClasses.length ? "none" : "bySelection";
+  s.allMatrixCNVHidden = hiddenCNVs.size == s.CNVClasses.length;
+  const hiddenMutations = new Set(s.hiddenVariants.filter((key2) => s.mutationClasses.find((k) => k === key2)));
+  s.hiddenMutations = [...hiddenMutations];
+  const PCset = new Set(s.proteinChangingMutations);
+  const TMset = new Set(s.truncatingMutations);
+  s.showMatrixMutation = !hiddenMutations.size ? "all" : hiddenMutations.size == s.mutationClasses.length ? "none" : hiddenMutations.size === s.mutationClasses.length - PCset.size && [...hiddenMutations].every((m) => !PCset.has(m)) ? "onlyPC" : hiddenMutations.size === s.mutationClasses.length - TMset.size && [...hiddenMutations].every((m) => !TMset.has(m)) ? "onlyTruncating" : "bySelection";
+  s.allMatrixMutationHidden = hiddenMutations.size == s.mutationClasses.length;
+  const tiebreakers = s.sortOptions.a?.sortPriority.find((sp) => sp.types.length == 1 && sp.types[0] == "geneVariant")?.tiebreakers || [];
+  s.sortByMutation = tiebreakers.find((tb) => tb.filter?.values[0]?.dt === 1)?.isOrdered ? "consequence" : "presence";
+  s.sortByCNV = tiebreakers.find((tb) => tb.filter?.values[0]?.dt === 4)?.disabled !== true;
+}
+
+export {
+  getPlotConfig,
+  setComputedConfig
+};
+//# sourceMappingURL=chunk-5TJQ6633.js.map

package/dist/chunk-5X5LI5YM.js

@@ -0,0 +1,254 @@
+import {
+  getMclassSorter,
+  getSampleGroupSorter,
+  getSampleSorter,
+  getTermSorter
+} from "./chunk-CDUNE45Q.js";
+import {
+  sample_match_termvaluesetting
+} from "./chunk-7IYJZZQI.js";
+import {
+  dtcnv,
+  dtfusionrna,
+  dtgeneexpression,
+  dtsnvindel
+} from "./chunk-7KRS7L4U.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-5X5LI5YM.js.map