@sjcrh/proteinpaint-client 2.205.0 → 2.206.1

package/dist/chunk-C5TU4AYP.js

@@ -0,0 +1,281 @@
+import {
+  getMclassSorter,
+  getSampleGroupSorter,
+  getSampleSorter,
+  getTermSorter
+} from "./chunk-LDWMVZYF.js";
+import {
+  setRelatedSamples
+} from "./chunk-C2MCQZWH.js";
+import {
+  filterVariantValues,
+  sample_match_termvaluesetting
+} from "./chunk-M4XXKTH2.js";
+import {
+  dtcnv,
+  dtfusionrna,
+  dtgeneexpression,
+  dtsnvindel
+} from "./chunk-IZUYLFOX.js";
+import {
+  __export
+} from "./chunk-HS5PO5ZQ.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);
+  this.samplesByAncestorId = /* @__PURE__ */ new Map();
+  const seenAncestorSamples = /* @__PURE__ */ new Set();
+  for (const sd of data.lst) {
+    if (seenAncestorSamples.has(sd.sample)) continue;
+    seenAncestorSamples.add(sd.sample);
+    if (!sd._ref_?.ancestors) continue;
+    for (const a of sd._ref_.ancestors) {
+      const id = a.ancestor_id;
+      if (id === void 0) continue;
+      if (!this.samplesByAncestorId.has(id)) this.samplesByAncestorId.set(id, /* @__PURE__ */ new Set());
+      this.samplesByAncestorId.get(id).add(sd);
+    }
+  }
+  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;
+  }
+  for (const [ancestor_id, samples] of this.samplesByAncestorId.entries()) {
+    if (samples.size < 2) this.samplesByAncestorId.delete(ancestor_id);
+  }
+  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 cell = row[$id];
+      const keys = term.type == "multivalue" && Array.isArray(cell.values) ? cell.values.map((v) => v.key) : [cell.key];
+      for (const key of keys) {
+        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);
+    if (this.config.chartType == "matrix" && s.sortBySampleAncestry) setRelatedSamples(grp);
+  }
+  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) {
+  let values = "value" in anno ? [anno.value] : anno.values;
+  if (!values) return { filteredValues: null, countedValues: null, renderedValues: null };
+  if (tw.term.type == "geneVariant" && tw.q?.type == "values" && tw.q.variantFilter) {
+    values = filterVariantValues(values, tw.q.variantFilter);
+  }
+  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-C5TU4AYP.js.map

package/dist/chunk-CMO5BR2S.js

@@ -0,0 +1,203 @@
+import {
+  tkt
+} from "./chunk-XDLCPJCK.js";
+import {
+  stratinput
+} from "./chunk-PF4DSFDR.js";
+import {
+  stratify_default
+} from "./chunk-4OLM3KSB.js";
+
+// src/vcf.tkconvert.js
+function vcf2dstk(arg) {
+  const ds = {
+    id2vcf: {},
+    label: arg.name || "Unnamed VCF file"
+  };
+  let vcfobj;
+  if (arg.file) {
+    const id = Math.random().toString();
+    vcfobj = {
+      file: arg.file,
+      indexURL: arg.indexURL,
+      vcfid: id
+    };
+    ds.id2vcf[id] = vcfobj;
+  } else if (arg.url) {
+    const id = Math.random().toString();
+    vcfobj = {
+      url: arg.url,
+      indexURL: arg.indexURL,
+      vcfid: id
+    };
+    ds.id2vcf[id] = vcfobj;
+  } else {
+    return ["no .file or .url"];
+  }
+  vcfobj.headernotloaded = true;
+  if (arg.samplenamemap) {
+    vcfobj.samplenamemap = arg.samplenamemap;
+  }
+  if (arg.variant2img) {
+    if (!arg.variant2img.path) return [".path missing from .variant2img{}"];
+  }
+  const tk = {
+    type: tkt.ds,
+    // to be loaded by loadvcftk() as a custom track, rather than "/dsdata" for official ds
+    isvcf: true,
+    name: ds.label,
+    ds,
+    populationfrequencyfilter: arg.populationfrequencyfilter,
+    vcfinfofilter: arg.vcfinfofilter,
+    itemlabelname: arg.itemlabelname,
+    viewrangeupperlimit: arg.viewrangeupperlimit,
+    variant2img: arg.variant2img,
+    axisheight: arg.axisheight
+  };
+  if (arg.url4variant) {
+    const err = check_url4variant(arg.url4variant);
+    if (err) return [".url4variant error: " + err];
+    tk.url4variant = arg.url4variant;
+  }
+  if (arg.button4variant) {
+    const err = check_button4variant(arg.button4variant);
+    if (err) return [".button4variant error: " + err];
+    tk.button4variant = arg.button4variant;
+  }
+  if (arg.sampleannotation) {
+    const sn = arg.sampleannotation;
+    if (!sn.annotation) return [".annotation{} missing from .sampleannotation"];
+    if (sn.levels) {
+      if (!Array.isArray(sn.levels)) return [".sampleannotation.levels should be array"];
+      const lst = [];
+      for (const sample in sn.annotation) {
+        const o = { sample_name: sample };
+        for (const k in sn.annotation[sample]) {
+          o[k] = sn.annotation[sample][k];
+        }
+        lst.push(o);
+      }
+      const nodes = stratinput(lst, sn.levels);
+      sn.root = stratify_default()(nodes);
+      sn.root.sum((i) => i.value);
+    }
+    if (sn.variantsunburst) {
+      if (!sn.levels) return [".levels missing when .variantsunburst is on from .sampleannotation"];
+    }
+    tk.ds.cohort = sn;
+  }
+  if (arg.vcfcohorttrack) {
+    if (!arg.vcfcohorttrack.file && !arg.vcfcohorttrack.url) return ["no .file or .url provided from .vcfcohorttrack"];
+    tk.ds.vcfcohorttrack = arg.vcfcohorttrack;
+  }
+  if (arg.germline2dvafplot) {
+    if (!arg.germline2dvafplot.individualkey) return [".individualkey missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.sampletypekey) return [".sampletypekey missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.xsampletype) return [".xsampletype missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.yleftsampletype) return [".yleftsampletype missing from germline2dvafplot"];
+    if (arg.germline2dvafplot.yrightsampletype) {
+      if (arg.germline2dvafplot.yrightsampletype == arg.germline2dvafplot.yleftsampletype)
+        return [".yrightsampletype should not be same as yleftsampletype"];
+    }
+    tk.ds.germline2dvafplot = arg.germline2dvafplot;
+  }
+  if (arg.vaf2coverageplot) {
+    if (arg.vaf2coverageplot.categorykey) {
+      if (!arg.vaf2coverageplot.categories)
+        return [".categories missing when .categorykey is in use for .vaf2coverageplot"];
+    }
+    tk.ds.vaf2coverageplot = arg.vaf2coverageplot;
+  }
+  if (arg.genotype2boxplot) {
+    if (arg.genotype2boxplot.boxplotvaluekey) {
+    } else if (arg.genotype2boxplot.sampleannotationkey) {
+      if (!tk.ds.cohort) return ["sampleannotation missing when using genotype2boxplot.sampleannotationkey"];
+      if (!tk.ds.cohort.annotation)
+        return ["sampleannotation.annotation missing when using genotype2boxplot.sampleannotationkey"];
+      let found = false;
+      for (const k in tk.ds.cohort.annotation) {
+        if (arg.genotype2boxplot.sampleannotationkey in tk.ds.cohort.annotation[k]) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return [arg.genotype2boxplot.sampleannotationkey + " not found in any sample annotation"];
+    } else {
+      return ["incomplete instruction for genotype2boxplot"];
+    }
+    tk.ds.genotype2boxplot = arg.genotype2boxplot;
+  }
+  if (arg.discardsymbolicallele) {
+    tk.ds.discardsymbolicallele = true;
+  }
+  if (arg.samplebynumericvalue) {
+    if (!arg.samplebynumericvalue.attrkey) return ["attrkey missing from samplebynumericvalue"];
+    if (!tk.ds.cohort) return ["sampleannotation missing when using samplebynumericvalue"];
+    if (!tk.ds.cohort.annotation) return ["sampleannotation.annotation missing when using samplebynumericvalue"];
+    let found = false;
+    for (const k in tk.ds.cohort.annotation) {
+      if (Number.isFinite(tk.ds.cohort.annotation[k][arg.samplebynumericvalue.attrkey])) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) return ["samplebynumericvalue.attrkey not found in any sample annotation"];
+    tk.ds.samplebynumericvalue = arg.samplebynumericvalue;
+  }
+  {
+    const g = arg.genotypebynumericvalue;
+    if (g) {
+      if (!g.refref) return [tk.name + ": refref missing from genotypebynumericvalue"];
+      if (!g.refalt) return [tk.name + ": refalt missing from genotypebynumericvalue"];
+      if (!g.altalt) return [tk.name + ": altalt missing from genotypebynumericvalue"];
+      if (!g.refref.infokey) return [tk.name + ": refref.infokey missing from genotypebynumericvalue"];
+      if (!g.refalt.infokey) return [tk.name + ": refalt.infokey missing from genotypebynumericvalue"];
+      if (!g.altalt.infokey) return [tk.name + ": altalt.infokey missing from genotypebynumericvalue"];
+      if (g.refref.genotypeCountInfokey || g.refalt.genotypeCountInfokey || g.altalt.genotypeCountInfokey) {
+        if (!g.refref.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.refref{}"];
+        if (!g.refalt.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.refalt{}"];
+        if (!g.altalt.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.altalt{}"];
+      }
+      tk.ds.genotypebynumericvalue = g;
+    }
+  }
+  if (arg.pointdown) {
+    tk.aboveprotein = false;
+  }
+  if (arg.dstk_novcferror) {
+    tk.dstk_novcferror = true;
+  }
+  return [null, tk];
+}
+function check_url4variant(lst) {
+  if (!Array.isArray(lst)) return "value is not an array";
+  for (const item of lst) {
+    if (!item.makeurl) {
+      return ".makeurl missing";
+    }
+    if (typeof item.makeurl != "function") {
+      return ".makeurl must be a function";
+    }
+  }
+  return false;
+}
+function check_button4variant(lst) {
+  if (!Array.isArray(lst)) return "value is not an array";
+  for (const item of lst) {
+    if (!item.makebutton) {
+      return ".makebutton missing";
+    }
+    if (typeof item.makebutton != "function") {
+      return ".makebutton must be a function";
+    }
+  }
+  return false;
+}
+
+export {
+  vcf2dstk
+};
+//# sourceMappingURL=chunk-CMO5BR2S.js.map