@sjcrh/proteinpaint-client 2.211.0 → 2.211.1-0

package/dist/chunk-4HTRCXLS.js

@@ -1,98 +0,0 @@
-import {
-  keyupEnter
-} from "./chunk-K7HFOAR7.js";
-import {
-  require_debounce
-} from "./chunk-KV4W2ACA.js";
-import {
-  Menu
-} from "./chunk-7XZA2XR2.js";
-import {
-  dofetch,
-  dofetch3
-} from "./chunk-GP4VLNMZ.js";
-import {
-  __toESM
-} from "./chunk-HS5PO5ZQ.js";
-
-// src/gene.js
-var import_debounce = __toESM(require_debounce(), 1);
-var tip;
-function gene_searchbox(p) {
-  if (!tip) {
-    tip = new Menu({ padding: "" });
-    tip.d.style("z-index", 1e3);
-  }
-  const input = p.div.append("input").attr("placeholder", "Search gene").style("width", p.width || "100px");
-  const printdiv = p.resultdiv || (p.tip ? p.tip.d : tip.d);
-  function fold() {
-    if (p.resultdiv) {
-      p.resultdiv.selectAll("*").remove();
-    } else if (p.tip) {
-      p.tip.hide();
-    } else {
-      tip.hide();
-    }
-  }
-  input.on("keyup", (event) => {
-    const str = event.target.value;
-    if (str.length <= 1) {
-      fold();
-      return;
-    }
-    if (keyupEnter(event)) {
-      const hitgene = printdiv.select(".sja_menuoption");
-      if (hitgene.size() > 0) {
-        p.callback(hitgene.text());
-        fold();
-      }
-      return;
-    }
-    debouncer();
-  });
-  input.node().focus();
-  function genesearch() {
-    dofetch("genelookup", { genome: p.genome, input: input.property("value") }).then((data) => {
-      if (data.error) throw data.error;
-      if (!data.hits) throw ".hits[] missing";
-      if (p.resultdiv) {
-        p.resultdiv.selectAll("*").remove();
-      } else if (p.tip) {
-        p.tip.clear().showunder(input.node());
-      } else {
-        tip.clear().showunder(input.node());
-      }
-      for (const name of data.hits) {
-        printdiv.append("div").attr("class", "sja_menuoption").text(name).on("click", () => {
-          p.callback(name);
-          fold();
-        });
-      }
-    }).catch((err) => {
-      printdiv.append("div").text(err.message || err);
-      if (err.stack) console.log(err.stack);
-    });
-  }
-  const debouncer = (0, import_debounce.debounce)(genesearch, 300);
-}
-function findgenemodel_bysymbol(genome, str) {
-  return dofetch3("genelookup", {
-    body: {
-      deep: 1,
-      input: str,
-      genome
-    }
-  }).then((data) => {
-    if (data.error) throw data.error;
-    if (!data.gmlst || data.gmlst.length == 0) return null;
-    return data.gmlst;
-  }).catch((e) => {
-    throw e;
-  });
-}
-
-export {
-  gene_searchbox,
-  findgenemodel_bysymbol
-};
-//# sourceMappingURL=chunk-4HTRCXLS.js.map

package/dist/chunk-55T2AMJ3.js

@@ -1,281 +0,0 @@
-import {
-  getMclassSorter,
-  getSampleGroupSorter,
-  getSampleSorter,
-  getTermSorter
-} from "./chunk-HTZJQNHP.js";
-import {
-  setRelatedSamples
-} from "./chunk-C2MCQZWH.js";
-import {
-  filterVariantValues,
-  sample_match_termvaluesetting
-} from "./chunk-6AFMWQXZ.js";
-import {
-  dtcnv,
-  dtfusionrna,
-  dtgeneexpression,
-  dtsnvindel
-} from "./chunk-57Z4VYLM.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-55T2AMJ3.js.map

package/dist/chunk-5JDG5NNA.js

@@ -1,203 +0,0 @@
-import {
-  tkt
-} from "./chunk-K7HFOAR7.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-5JDG5NNA.js.map