@sjcrh/proteinpaint-client 2.166.0 → 2.167.1

package/dist/singlecell-NWANPXWM.js

@@ -0,0 +1,80 @@
+import {
+  appInit
+} from "./chunk-3MGBC64I.js";
+import "./chunk-QX5QVWUP.js";
+import "./chunk-SKMFMGCD.js";
+import "./chunk-SEL5UNRC.js";
+import "./chunk-LMELY5Z2.js";
+import "./chunk-J7IU77CA.js";
+import "./chunk-BTYCW3D5.js";
+import "./chunk-W5EG334J.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-MK7RRJTX.js";
+import "./chunk-DKI7YOTJ.js";
+import "./chunk-6VQ4C735.js";
+import "./chunk-TGZA4ETW.js";
+import "./chunk-5MWX5HUZ.js";
+import "./chunk-IQIXGTQV.js";
+import "./chunk-ZFFHOEBE.js";
+import {
+  copyMerge
+} from "./chunk-DDOM4XYV.js";
+import "./chunk-7NTZWOJV.js";
+import "./chunk-LD45BCVM.js";
+import "./chunk-RA5EXEHB.js";
+import "./chunk-2MN5JLZB.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import "./chunk-W2IWHXLL.js";
+import "./chunk-5OHXYXLD.js";
+import "./chunk-UJUXE42U.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-NDWTN4U5.js";
+import "./chunk-HFNDKYVF.js";
+
+// gdc/singlecell.ts
+var gdcGenome = "hg38";
+var gdcDslabel = "GDC";
+async function init(arg, holder, genomes) {
+  const plotAppApi = await appInit({
+    holder,
+    state: {
+      genome: gdcGenome,
+      dslabel: gdcDslabel,
+      termfilter: { filter0: arg.filter0 },
+      plots: arg.state?.plots || [{ chartType: "singleCellPlot" }]
+    },
+    genome: genomes[gdcGenome],
+    app: copyMerge({}, arg.opts?.app || {}),
+    opts: {
+      singleCellPlot: arg.opts?.singleCellPlot || {}
+    }
+  });
+  const api = {
+    update: async (updateArg) => {
+      if (!plotAppApi) return;
+      if ("filter0" in updateArg) {
+        plotAppApi.dispatch({
+          type: "app_refresh",
+          subactions: [
+            {
+              type: "filter_replace",
+              filter0: updateArg.filter0
+            }
+          ]
+        });
+      } else {
+        plotAppApi.dispatch({
+          type: "plot_edit",
+          id: plotAppApi.getState().plots[0].id,
+          config: updateArg
+        });
+      }
+    }
+  };
+  return api;
+}
+export {
+  init
+};
+//# sourceMappingURL=singlecell-NWANPXWM.js.map

package/dist/snp-PSRNMTL6.js

@@ -0,0 +1,73 @@
+import {
+  addGeneSearchbox
+} from "./chunk-W5EG334J.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-MK7RRJTX.js";
+import "./chunk-DKI7YOTJ.js";
+import "./chunk-6VQ4C735.js";
+import {
+  Menu
+} from "./chunk-TGZA4ETW.js";
+import "./chunk-5MWX5HUZ.js";
+import "./chunk-IQIXGTQV.js";
+import "./chunk-ZFFHOEBE.js";
+import "./chunk-DDOM4XYV.js";
+import "./chunk-7NTZWOJV.js";
+import "./chunk-LD45BCVM.js";
+import "./chunk-RA5EXEHB.js";
+import "./chunk-2MN5JLZB.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import "./chunk-W2IWHXLL.js";
+import "./chunk-5OHXYXLD.js";
+import "./chunk-UJUXE42U.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-NDWTN4U5.js";
+import "./chunk-HFNDKYVF.js";
+
+// termdb/handlers/snp.ts
+var SearchHandler = class {
+  init(opts) {
+    this.callback = opts.callback;
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: opts.holder,
+      searchOnly: "snp",
+      allowVariant: true,
+      callback: () => this.selectSnp(geneSearch)
+    });
+  }
+  async selectSnp(geneSearch) {
+    const { chr, ref, alt, fromWhat } = geneSearch;
+    if (!chr || !ref || !alt || !fromWhat) throw "missing chr, ref, alt, or fromWhat of snp";
+    let start, stop;
+    if (!geneSearch.start && !geneSearch.stop) {
+      if (geneSearch.pos) {
+        start = geneSearch.pos - 1;
+        stop = geneSearch.pos;
+      } else {
+        throw "missing coordinate of snp";
+      }
+    } else {
+      start = geneSearch.start;
+      stop = geneSearch.stop;
+    }
+    const term = {
+      id: fromWhat,
+      chr,
+      start,
+      stop,
+      name: fromWhat,
+      ref,
+      alt: typeof alt == "string" ? [alt] : alt,
+      // is string if input to geneSearch was in variant or hgvs format // TODO: update genesearch.ts to parse alternative alleles from any input format into arrays
+      type: "snp"
+    };
+    this.callback(term);
+  }
+};
+export {
+  SearchHandler
+};
+//# sourceMappingURL=snp-PSRNMTL6.js.map

package/dist/snplocus-QCAVDYLR.js

@@ -0,0 +1,199 @@
+import {
+  makeSnpSelect,
+  mayRestrictAncestry
+} from "./chunk-T5BDYCFO.js";
+import "./chunk-7OYOC7XY.js";
+import {
+  addGeneSearchbox,
+  filterInit,
+  getNormalRoot
+} from "./chunk-W5EG334J.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-MK7RRJTX.js";
+import "./chunk-DKI7YOTJ.js";
+import "./chunk-6VQ4C735.js";
+import "./chunk-TGZA4ETW.js";
+import "./chunk-5MWX5HUZ.js";
+import "./chunk-IQIXGTQV.js";
+import "./chunk-ZFFHOEBE.js";
+import "./chunk-DDOM4XYV.js";
+import "./chunk-7NTZWOJV.js";
+import "./chunk-LD45BCVM.js";
+import "./chunk-RA5EXEHB.js";
+import "./chunk-2MN5JLZB.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import "./chunk-W2IWHXLL.js";
+import "./chunk-5OHXYXLD.js";
+import "./chunk-UJUXE42U.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-NDWTN4U5.js";
+import "./chunk-HFNDKYVF.js";
+
+// termsetting/handlers/snplocus.ts
+var term_name = "Variants in a locus";
+function getHandler(self) {
+  return {
+    getPillName() {
+      return self.term.name;
+    },
+    getPillStatus() {
+      if (!self.term || !self.q) return;
+      if (!self.term.snps) throw `Missing term.snps [snplocs.ts getPillStatus()]`;
+      let text = `${self.q.chr}:${self.q.start}-${self.q.stop}, ${self.term.snps.length} variant${self.term.snps.length > 1 ? "s" : ""}`;
+      if (self.term.reachedVariantLimit) {
+        text += '<span style="margin-left: 6px; background:#aaa; font-size:1em;font-style: normal; border-radius: 7px;color:white;padding:0px 5px;">&#9888;<span>';
+      }
+      return { text };
+    },
+    validateQ(data) {
+      validateQ(data);
+    },
+    async showEditMenu(div) {
+      await makeEditMenu(self, div);
+    }
+    /* no need for postMain()
+    cache file contains all samples,
+    variants in a cache file is only determined by locus range and info fields
+    thus no need to regenerate cache file upon subcohort or filter change via pill.main()
+    async postMain() {
+    	if (self.q && self.q.chr) {
+    		await validateInput(self)
+    	}
+    }
+    */
+  };
+}
+async function makeEditMenu(self, div0) {
+  const div = div0.append("div").style("margin", "15px");
+  const select_ancestry = await mayRestrictAncestry(self, div);
+  const coordResult = addGeneSearchbox({
+    genome: self.opts.genomeObj,
+    tip: self.dom.tip2,
+    row: div.append("div").style("margin-top", "20px"),
+    defaultCoord: self.q && self.q.chr ? { chr: self.q.chr, start: self.q.start, stop: self.q.stop } : void 0
+  });
+  div.select(".sja_genesearchinput").style("margin", "0px");
+  div.append("span").style("margin", "5px 0px").style("display", "inline-block").style("opacity", 0.4).style("font-size", ".7em").html(
+    '"Gene": Gene name (e.g. AKT1)</br>"Position": chr:start-stop (e.g. chr1:5000-6000)</br>"dbSNP": dbSNP accession (e.g. rs1042522)'
+  );
+  await mayDisplayVariantFilter(self, self.q?.variant_filter, div);
+  const [input_AFcutoff, select_alleleType, select_geneticModel] = makeSnpSelect(
+    div.append("div").attr("class", "sjpp-snp-select").style("margin-top", "15px"),
+    self,
+    "snplocus"
+  );
+  if (self.usecase.target == "dataDownload") div.select(".sjpp-snp-select").style("display", "none");
+  const btnRow = div.append("div").style("margin-top", "15px");
+  btnRow.append("button").style("margin-top", "15px").text("Submit").on("click", async (event) => {
+    if (!coordResult.chr) return window.alert("Invalid coordinate");
+    event.target.disabled = true;
+    event.target.innerHTML = "Validating input...";
+    if (self.term) {
+    } else {
+      self.term = { id: makeId() };
+    }
+    if (!self.q) self.q = {};
+    self.term.type = "snplocus";
+    self.q.chr = coordResult.chr;
+    self.q.start = coordResult.start;
+    self.q.stop = coordResult.stop;
+    self.term.name = term_name;
+    delete self.term.snps;
+    self.q.variant_filter = getNormalRoot(self.variantFilter.active);
+    await validateInput(self);
+    {
+      const v = Number(input_AFcutoff.property("value"));
+      self.q.AFcutoff = v < 0 || v >= 100 ? 5 : v;
+    }
+    self.q.alleleType = select_alleleType.property("selectedIndex");
+    self.q.geneticModel = select_geneticModel.property("selectedIndex");
+    if (select_ancestry) {
+      self.q.restrictAncestry = select_ancestry.node().options[select_ancestry.property("selectedIndex")].__ancestry_obj;
+    }
+    self.api.runCallback();
+  });
+  btnRow.append("span").style("padding-left", "15px").style("opacity", 0.8).style("font-size", ".8em").text(
+    self.usecase.target == "dataDownload" ? "" : "Variants will be treated individually in separate regression models"
+  );
+}
+async function validateInput(self) {
+  const data = await self.vocabApi.validateSnps(self.q);
+  if (data.error) throw data.error;
+  self.q.cacheid = data.cacheid;
+  self.term.snps = data.snps;
+  self.term.reachedVariantLimit = data.reachedVariantLimit;
+}
+function validateQ(data) {
+  const q = data.q;
+  if (!Number.isFinite(q.AFcutoff)) throw "AFcutoff is not number";
+  if (q.AFcutoff < 0 || q.AFcutoff > 100) throw "AFcutoff is not within 0 to 100";
+  if (![0, 1].includes(q.alleleType)) throw "alleleType value is not one of 0/1";
+  if (![0, 1, 2, 3].includes(q.geneticModel)) throw "geneticModel value is not one of 0/1";
+  if (!q.chr) throw "chr missing";
+  if (!Number.isInteger(q.start)) throw "start coordinate is not integer";
+  if (!Number.isInteger(q.stop)) throw "stop coordinate is not integer";
+  if (q.start < 0) throw "start < 0";
+  if (q.stop <= q.start) throw "stop <= start";
+}
+async function fillTW(tw, vocabApi) {
+  try {
+    validateQ(tw);
+  } catch (e) {
+    throw "snplocus validateQ(): " + e;
+  }
+  if (!tw.term.name) tw.term.name = term_name;
+  if (tw.id == void 0 || tw.id == "") {
+    if (tw.term.id == void 0 || tw.term.id == "") {
+      tw.term.id = makeId();
+    }
+    tw.id = tw.term.id;
+  } else {
+    if (tw.term.id == void 0 || tw.term.id == "") {
+      tw.term.id = tw.id;
+    }
+  }
+  await validateInput({
+    term: tw.term,
+    q: tw.q,
+    vocabApi
+  });
+}
+function makeId() {
+  return "snplocus" + Math.random();
+}
+async function mayDisplayVariantFilter(self, filterInState, holder, callback2) {
+  if (!self.variantFilter) {
+    self.variantFilter = await self.vocabApi.get_variantFilter();
+  }
+  if (!self.variantFilter.terms) {
+    return;
+  }
+  if (!self.variantFilter.opts) throw "variantFilter.opts{} missing";
+  if (!self.variantFilter.filter) throw ".filter missing from variantFilter{}";
+  if (!Array.isArray(self.variantFilter.terms) || self.variantFilter.terms.length == 0)
+    throw "variantFilter.terms[] is not non-empty array";
+  if (filterInState) {
+    self.variantFilter.active = JSON.parse(JSON.stringify(filterInState));
+  } else {
+    self.variantFilter.active = JSON.parse(JSON.stringify(self.variantFilter.filter));
+  }
+  const div = holder.append("div").style("margin-top", "15px");
+  div.append("span").text("VARIANT FILTERS").style("font-size", ".8em").style("opacity", 0.5);
+  const filterBody = div.append("div");
+  filterInit({
+    joinWith: self.variantFilter.opts.joinWith,
+    emptyLabel: "+Variant Filter",
+    holder: filterBody,
+    vocab: { terms: self.variantFilter.terms },
+    callback: async (filter) => {
+      self.variantFilter.active = filter;
+      if (callback2) await callback2();
+    }
+  }).main(self.variantFilter.active);
+}
+export {
+  fillTW,
+  getHandler
+};
+//# sourceMappingURL=snplocus-QCAVDYLR.js.map

package/dist/spliceevent.a53ss.diagram-SGDJKUEC.js

@@ -0,0 +1,142 @@
+import {
+  font
+} from "./chunk-W5EG334J.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-MK7RRJTX.js";
+import "./chunk-DKI7YOTJ.js";
+import {
+  IN_frame,
+  exoncolor
+} from "./chunk-6VQ4C735.js";
+import "./chunk-TGZA4ETW.js";
+import "./chunk-5MWX5HUZ.js";
+import "./chunk-IQIXGTQV.js";
+import "./chunk-ZFFHOEBE.js";
+import "./chunk-DDOM4XYV.js";
+import "./chunk-7NTZWOJV.js";
+import "./chunk-LD45BCVM.js";
+import "./chunk-RA5EXEHB.js";
+import "./chunk-2MN5JLZB.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import "./chunk-W2IWHXLL.js";
+import "./chunk-5OHXYXLD.js";
+import "./chunk-UJUXE42U.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-NDWTN4U5.js";
+import "./chunk-HFNDKYVF.js";
+
+// src/spliceevent.a53ss.diagram.js
+var junctionBcolor = "#990000";
+var color_truncateexon = "#00A352";
+function spliceevent_a53ss_diagram_default(arg) {
+  const evt = arg.event;
+  if (!evt) {
+    arg.holder.text(".event missing");
+    return;
+  }
+  if (evt.a5ss == void 0 && evt.a3ss == void 0) {
+    arg.holder.text("not a5ss or a3ss");
+    return;
+  }
+  const exonwidth = 30;
+  const intronwidth = 30;
+  const exonheight = 20;
+  const distfontsize = exonheight - 5;
+  const junctionheight = 20;
+  const xpad = 30;
+  const ypad = 20;
+  const svg = arg.holder.append("svg");
+  const g = svg.append("g").attr("transform", "translate(" + xpad + "," + ypad + ")");
+  const distlabel = evt.sitedist + " nt";
+  let distlabelw;
+  g.append("text").text(distlabel).attr("font-size", distfontsize).attr("font-family", font).each(function() {
+    distlabelw = this.getBBox().width;
+  }).remove();
+  const distlabelpad = 5;
+  let leftinexon = false;
+  let rightinexon = false;
+  let leftinintron = false;
+  let rightinintron = false;
+  if (evt.a5ss) {
+    if (evt.altinexon) leftinexon = true;
+    else leftinintron = true;
+  } else {
+    if (evt.altinexon) rightinexon = true;
+    else rightinintron = true;
+  }
+  let x = 0;
+  let intronstart;
+  let intronstop;
+  g.append("rect").attr("fill", exoncolor).attr("stroke", exoncolor).attr("x", x).attr("y", junctionheight).attr("width", exonwidth).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+  g.append("text").text("e" + (evt.exon5idx + 1)).attr("text-anchor", "middle").attr("x", x + exonwidth / 2).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+  x += exonwidth;
+  if (leftinexon) {
+    g.append("rect").attr("fill", color_truncateexon).attr("stroke", color_truncateexon).attr("x", x).attr("y", junctionheight).attr("width", distlabelw + distlabelpad * 2).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+    g.append("text").text(distlabel).attr("text-anchor", "middle").attr("x", x + distlabelw / 2 + distlabelpad).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+    x += distlabelw + distlabelpad * 2;
+  }
+  intronstart = x;
+  if (leftinintron || rightinintron) {
+    if (leftinintron) {
+    } else {
+      x += intronwidth;
+    }
+    g.append("rect").attr("fill", "none").attr("stroke", exoncolor).attr("x", x).attr("y", junctionheight).attr("width", distlabelw + distlabelpad * 2).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+    g.append("text").text(distlabel).attr("text-anchor", "middle").attr("x", x + distlabelw / 2 + distlabelpad).attr("y", junctionheight + exonheight / 2).attr("font-size", distfontsize).attr("font-family", font).attr("dominant-baseline", "central");
+    x += distlabelw + distlabelpad * 2;
+    if (leftinintron) {
+      x += intronwidth;
+    }
+  } else {
+    x += intronwidth;
+  }
+  intronstop = x;
+  g.append("line").attr("x1", intronstart + (leftinintron ? distlabelw + distlabelpad * 2 : 0)).attr("y1", junctionheight + exonheight / 2).attr("x2", intronstop - (rightinintron ? distlabelw + distlabelpad * 2 : 0)).attr("y2", junctionheight + exonheight / 2).attr("stroke", exoncolor).attr("shape-rendering", "crispEdges");
+  if (rightinexon) {
+    g.append("rect").attr("fill", color_truncateexon).attr("stroke", color_truncateexon).attr("x", x).attr("y", junctionheight).attr("width", distlabelw + distlabelpad * 2).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+    g.append("text").text(distlabel).attr("text-anchor", "middle").attr("x", x + distlabelw / 2 + distlabelpad).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+    x += distlabelw + distlabelpad * 2;
+  }
+  g.append("rect").attr("fill", exoncolor).attr("stroke", exoncolor).attr("x", x).attr("y", junctionheight).attr("width", exonwidth).attr("height", exonheight).attr("shape-rendering", "crispEdges");
+  g.append("text").text("e" + (evt.exon5idx + 1 + 1)).attr("text-anchor", "middle").attr("x", x + exonwidth / 2).attr("y", junctionheight + exonheight / 2).attr("fill", "white").attr("dominant-baseline", "central").attr("font-size", distfontsize).attr("font-family", font);
+  {
+    let x1, x2;
+    if (leftinexon || leftinintron) {
+      x2 = intronstop;
+      if (leftinexon) {
+        x1 = intronstart - distlabelw - distlabelpad * 2;
+      } else {
+        x1 = intronstart + distlabelw + distlabelpad * 2;
+      }
+    } else {
+      x1 = intronstart;
+      if (rightinintron) {
+        x2 = intronstop - distlabelw - distlabelpad * 2;
+      } else {
+        x2 = intronstop + distlabelw + distlabelpad * 2;
+      }
+    }
+    g.append("path").attr("d", "M" + x1 + "," + junctionheight + "L" + (x1 + x2) / 2 + ",0L" + x2 + "," + junctionheight).attr("stroke", junctionBcolor).attr("fill", "none");
+    g.append("text").text(evt.junctionB.v + (evt.frame != void 0 ? evt.frame == IN_frame ? ", in frame" : ",out of frame" : "")).attr("x", (x1 + x2) / 2).attr("y", -1).attr("text-anchor", "middle").attr("font-size", distfontsize).attr("fill", junctionBcolor);
+  }
+  let jAreadcounttext;
+  {
+    const line = g.append("path").attr(
+      "d",
+      "M" + intronstart + "," + (junctionheight + exonheight) + "L" + (intronstart + intronstop) / 2 + "," + (junctionheight * 2 + exonheight) + "L" + intronstop + "," + (junctionheight + exonheight)
+    ).attr("stroke", exoncolor).attr("fill", "none");
+    const nj = evt.junctionA;
+    if (nj) {
+      jAreadcounttext = g.append("text").text(nj.v).attr("x", (intronstart + intronstop) / 2).attr("y", junctionheight * 2 + exonheight + 1).attr("text-anchor", "middle").attr("font-size", distfontsize).attr("dominant-baseline", "hanging");
+    } else {
+      line.attr("stroke-dasharray", "3,3");
+    }
+  }
+  svg.attr("width", xpad * 2 + exonwidth * 2 + intronwidth + distlabelw + distlabelpad * 2).attr("height", ypad * 2 + junctionheight * 2 + exonheight);
+  return jAreadcounttext;
+}
+export {
+  spliceevent_a53ss_diagram_default as default
+};
+//# sourceMappingURL=spliceevent.a53ss.diagram-SGDJKUEC.js.map