@sjcrh/proteinpaint-client 2.210.1 → 2.211.1-0

package/dist/chunk-IHUP4WZT.js

@@ -0,0 +1,299 @@
+import {
+  first_genetrack_tolist,
+  gmmode,
+  sayerror
+} from "./chunk-UODENFH4.js";
+import {
+  dofetch3
+} from "./chunk-RMUK3TLD.js";
+import {
+  codon_stop,
+  nt2aa,
+  proteinDomainColorScale
+} from "./chunk-57Z4VYLM.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// common/snp.js
+async function string2snp(genome, str) {
+  const data = await dofetch3("snp", {
+    method: "POST",
+    body: JSON.stringify({ byName: true, genome: genome.name, lst: [str] })
+  });
+  if (data.error) throw data.error;
+  if (!data.results || data.results.length == 0) throw str + ": not a SNP";
+  for (const i of data.results) {
+    const chr = genome.chrlookup[i.chrom.toUpperCase()];
+    if (chr && chr.major) {
+      return {
+        chr: i.chrom,
+        start: i.chromStart,
+        stop: i.chromEnd
+      };
+    }
+  }
+  const r = data.results[0];
+  return {
+    chr: r.chrom,
+    start: r.chromStart,
+    stop: r.chromEnd
+  };
+}
+
+// src/block.init.js
+async function block_init_default(arg) {
+  if (!arg.holder) throw "No holder for block.init";
+  if (!arg.genome) throw "no genome";
+  if (arg.holder instanceof Element) arg.holder = select_default(arg.holder);
+  if (!arg.tklst) arg.tklst = [];
+  if (arg.query) {
+    await step1_findgm(arg);
+    return;
+  }
+  if (arg.model && arg.allmodels) {
+    await step2_getseq(arg);
+    return;
+  }
+}
+async function step1_findgm(arg) {
+  const wait = arg.holder.append("p").style("font-size", "2em").style("color", "#858585").text("Searching for " + arg.query + " ...");
+  const data = await dofetch3("genelookup", {
+    body: { deep: 1, input: arg.query, genome: arg.genome.name }
+  });
+  if (!data) throw "querying genes: server error";
+  if (data.error) throw "error querying genes: " + data.error;
+  if (!data.gmlst || data.gmlst.length == 0) {
+    if (arg.genome.hasSNP) {
+      try {
+        const r = await string2snp(arg.genome, arg.query);
+        wait.remove();
+        const par = {
+          genome: arg.genome,
+          holder: arg.holder,
+          chr: r.chr,
+          start: Math.max(0, r.start - 300),
+          stop: r.start + 300,
+          nobox: true,
+          tklst: arg.tklst,
+          debugmode: arg.debugmode
+        };
+        first_genetrack_tolist(arg.genome, par.tklst);
+        const b = await import("./block-XCJDVW4D.js");
+        const block = new b.Block(par);
+        block.addhlregion(r.chr, r.start, r.stop - 1);
+      } catch (e) {
+        wait.text("Not a gene or SNP: " + arg.query);
+      }
+    } else {
+      wait.text("No match to gene: " + arg.query);
+    }
+    return;
+  }
+  wait.remove();
+  arg.allmodels = data.gmlst;
+  for (const m of arg.allmodels) {
+    if (m.isoform.toUpperCase() == (data.found_isoform ? data.found_isoform.toUpperCase() : arg.query.toUpperCase())) {
+      arg.model = m;
+      await step2_getseq(arg);
+      return;
+    }
+  }
+  const defaultisoforms = [];
+  for (const m of arg.allmodels) {
+    if (!m.isoform) throw "isoform missing from one gene model: " + JSON.stringify(m);
+    const n = m.isoform.toUpperCase();
+    if (arg.genome.isoformcache.has(n)) {
+      let nothas = true;
+      for (const m2 of arg.genome.isoformcache.get(n)) {
+        if (m2.chr == m.chr && m2.start == m.start && m2.stop == m.stop && m2.strand == m.strand) {
+          nothas = false;
+          break;
+        }
+      }
+      if (nothas) {
+        arg.genome.isoformcache.get(n).push(m);
+      }
+    } else {
+      arg.genome.isoformcache.set(n, [m]);
+    }
+    if (m.isoform.toUpperCase() == arg.query.toUpperCase()) {
+      defaultisoforms.push(m);
+      break;
+    }
+    if (m.isdefault) {
+      defaultisoforms.push(m);
+    }
+  }
+  if (defaultisoforms.length == 1) {
+    arg.model = defaultisoforms[0];
+  } else if (defaultisoforms.length > 1) {
+    for (const m of defaultisoforms) {
+      if (m.chr == "chrY") {
+        continue;
+      }
+      const chr = arg.genome.chrlookup[m.chr.toUpperCase()];
+      if (!chr) {
+        continue;
+      }
+      if (!chr.major) {
+        continue;
+      }
+      arg.model = m;
+      break;
+    }
+    if (!arg.model) {
+      arg.model = defaultisoforms[0];
+    }
+  }
+  if (!arg.model) {
+    arg.model = arg.allmodels[0];
+  }
+  await step2_getseq(arg);
+}
+async function step2_getseq(arg) {
+  if (arg.model.genomicseq) {
+    checker();
+    step2_getpdomain(arg);
+    return;
+  }
+  const par = {
+    genome: arg.genome.name,
+    coord: arg.model.chr + ":" + (arg.model.start + 1) + "-" + arg.model.stop
+  };
+  const data = await dofetch3("ntseq", { method: "POST", body: JSON.stringify(par) });
+  if (!data) throw "getting sequence: server error";
+  if (data.error) throw "getting sequence: " + data.error;
+  if (!data.seq) throw "no nt seq???";
+  arg.model.genomicseq = data.seq.toUpperCase();
+  arg.model.aaseq = nt2aa(arg.model);
+  checker();
+  await step2_getpdomain(arg);
+  function checker() {
+    if (arg.model.aaseq) {
+      const stop = arg.model.aaseq.indexOf(codon_stop);
+      const cdslen = arg.model.cdslen - (arg.model.startCodonFrame ? 3 - arg.model.startCodonFrame : 0);
+      if (stop != -1 && stop < cdslen / 3 - 1) {
+        sayerror(arg.holder, "Translating " + arg.model.isoform + " ends at " + stop + " AA, expecting " + cdslen / 3);
+      }
+    }
+  }
+}
+async function step2_getpdomain(arg) {
+  const isoform2gm = /* @__PURE__ */ new Map();
+  for (const m of arg.allmodels) {
+    if (!m.pdomains) {
+      m.pdomains = [];
+      m.domain_hidden = {};
+      if (!isoform2gm.has(m.isoform)) isoform2gm.set(m.isoform, []);
+      isoform2gm.get(m.isoform).push(m);
+    }
+  }
+  if (isoform2gm.size == 0) {
+    await step3(arg);
+    return;
+  }
+  const data = await dofetch3("pdomain", {
+    method: "POST",
+    body: JSON.stringify({ genome: arg.genome.name, isoforms: [...isoform2gm.keys()] })
+  });
+  if (data.error) throw "error getting protein domain: " + data.error;
+  if (!Array.isArray(data.lst)) throw ".lst[] not array";
+  for (const a of data.lst) {
+    for (const m of isoform2gm.get(a.name)) {
+      m.pdomains = a.pdomains;
+      if (arg.hidePdomain) {
+        for (const i of a.pdomains) {
+          m.domain_hidden[i.name + i.description] = 1;
+        }
+      }
+    }
+  }
+  if (arg.geneDomains) {
+    if (typeof arg.geneDomains != "object") throw "geneDomains not object";
+    for (const isoform in arg.geneDomains) {
+      const lst = isoform2gm.get(isoform);
+      if (!lst) throw `unknown isoform ${isoform} from geneDomains{}`;
+      for (const g of lst) {
+        if (!g.pdomains) g.pdomains = [];
+        if (!Array.isArray(arg.geneDomains[isoform])) throw `geneDomains[${isoform}] not array`;
+        for (const b of arg.geneDomains[isoform]) {
+          if (typeof b != "object") throw "element from geneDomains[] not object";
+          if (!Number.isInteger(b.start)) throw "start not integer from geneDomains[]";
+          if (!Number.isInteger(b.stop)) throw "stop not integer from geneDomains[]";
+          if (b.start > b.stop) throw "start>stop from geneDomains[]";
+          if (!b.name) b.name = "Custom domain";
+          if (!g.pdomains.find((a) => a.start == b.start && a.stop == b.stop && a.name == b.name)) g.pdomains.push(b);
+        }
+      }
+    }
+  }
+  const s = proteinDomainColorScale();
+  for (const lst of isoform2gm.values()) {
+    for (const g of lst) {
+      for (const d of g.pdomains || []) {
+        if (!d.color) d.color = s(d.name + d.description);
+      }
+    }
+  }
+  await step3(arg);
+}
+async function step3(arg) {
+  let mode = arg.gmmode;
+  if (!mode) {
+    if (arg.model.cdslen) {
+      mode = gmmode.protein;
+    } else {
+      mode = gmmode.exononly;
+    }
+  }
+  if (arg.dataset) {
+    if (!Array.isArray(arg.dataset)) throw "dataset is not array";
+    for (const dsname of arg.dataset) {
+      if (arg.genome.datasets[dsname] && !arg.genome.datasets[dsname].legacyDsIsUninitiated) continue;
+      const d = await dofetch3(`getDataset?genome=${arg.genome.name}&dsname=${dsname}`);
+      if (d.error) throw `invalid name from dataset[]: ${d.error}`;
+      if (!d.ds) throw ".ds missing";
+      const ds = arg.genome.datasets[d.ds.label];
+      Object.assign(ds, d.ds);
+      const _ = await import("./legacyDataset-IEFWFVS6.js");
+      _.validate_oldds(ds);
+      delete ds.legacyDsIsUninitiated;
+    }
+  }
+  const b = await import("./block-XCJDVW4D.js");
+  arg.__blockInstance = new b.Block({
+    genome: arg.genome,
+    holder: arg.holder,
+    nobox: true,
+    usegm: arg.model,
+    gmstackheight: 37,
+    allgm: arg.allmodels,
+    datasetlst: arg.dataset,
+    legacyDsFilter: arg.legacyDsFilter,
+    mset: arg.mset,
+    hlaachange: arg.hlaachange,
+    hlvariants: arg.hlvariants,
+    hlregions: arg.hlregions,
+    aarange: arg.aarange,
+    gmmode: mode,
+    hidedatasetexpression: arg.hidedatasetexpression,
+    hidegenecontrol: arg.hidegenecontrol,
+    hidegenelegend: arg.hidegenelegend,
+    variantPageCall_snv: arg.variantPageCall_snv,
+    datasetqueries: arg.datasetqueries,
+    samplecart: arg.samplecart,
+    debugmode: arg.debugmode,
+    tklst: arg.tklst,
+    mclassOverride: arg.mclassOverride,
+    hide_dsHandles: arg.hide_dsHandles,
+    onloadalltk_always: arg.onloadalltk_always,
+    onAddRemoveTk: arg.onAddRemoveTk
+  });
+}
+
+export {
+  string2snp,
+  block_init_default
+};
+//# sourceMappingURL=chunk-IHUP4WZT.js.map

package/dist/chunk-JPRCZTWX.js

@@ -0,0 +1,255 @@
+import {
+  first_genetrack_tolist
+} from "./chunk-UODENFH4.js";
+import {
+  HYPER_COLOR,
+  HYPO_COLOR
+} from "./chunk-RMUK3TLD.js";
+
+// plots/dmr/settings/defaults.ts
+function getDefaultDMRSettings(opts) {
+  const overrides = opts.settings || {};
+  const dm = opts?.app?.vocabApi?.termdbConfig?.queries?.dnaMethylation;
+  const chr = opts?.coordinateOverride?.chr;
+  const elementScale = dm?.regionAnalysis == "element" || Array.isArray(dm?.cpgChroms) && !!chr && !dm.cpgChroms.includes(chr);
+  const defaults = {
+    blockWidth: 800,
+    pad: elementScale ? 1e5 : 2e3,
+    lambda: elementScale ? 5e4 : 1e3,
+    C: 2,
+    fdr_cutoff: 0.05,
+    colors: {
+      group1: "#3b5ee6",
+      group2: "#c04e00",
+      hyper: HYPER_COLOR,
+      hypo: HYPO_COLOR
+    },
+    maxLoessRegion: 25e4,
+    minProbesForCi: 10,
+    backend: "rust",
+    maxRegionSize: 5e6
+  };
+  if (overrides.colors) {
+    Object.assign(defaults.colors, overrides.colors);
+    delete overrides.colors;
+  }
+  return Object.assign(defaults, overrides);
+}
+
+// plots/dmr/viewModel/DmrViewModel.ts
+var CCRE_TRACK_NAME = "ENCODE cCREs";
+var DmrViewModel = class {
+  constructor(dmrResult, config, genomeObj, queryChr, queryStart, queryStop) {
+    const { settings } = config;
+    const dmrBedItems = this.makeDmrBedItems(dmrResult, settings);
+    const sigCpgBedItems = this.makeSigCpgBedItems(dmrResult, settings, queryChr, queryStart, queryStop);
+    const xRange = (queryStop ?? 0) - (queryStart ?? 0);
+    const loess = dmrResult.diagnostic?.loess;
+    const showLoess = !!(loess && loess.group1_fitted.length > 0 && loess.group2_fitted.length > 0);
+    const showDots = xRange <= settings.dmr.maxLoessRegion;
+    const betaTrackResult = dmrResult.diagnostic ? this.renderBetaTrack(
+      dmrResult.diagnostic,
+      config,
+      settings.dmr.blockWidth,
+      showLoess,
+      showDots,
+      queryStart,
+      queryStop
+    ) : void 0;
+    this.viewData = {
+      tklst: this.buildTrackList(dmrBedItems, sigCpgBedItems, genomeObj, betaTrackResult?.img),
+      legendRows: this.buildLegendData(
+        config,
+        dmrResult.dmrs,
+        sigCpgBedItems,
+        showLoess,
+        showDots,
+        betaTrackResult?.showCi ?? false
+      ),
+      diagnostic: dmrResult.diagnostic,
+      dmrs: dmrResult.dmrs,
+      dmrBedItems,
+      showLoess,
+      showDots
+    };
+  }
+  buildTrackList(dmrBedItems, sigCpgBedItems, genomeObj, betaTrackImg) {
+    const tklst = [];
+    first_genetrack_tolist(genomeObj, tklst);
+    const ccre = (genomeObj?.tracks || []).find((t) => t.name == CCRE_TRACK_NAME);
+    if (ccre) tklst.push(structuredClone(ccre));
+    tklst.push({ type: "bedj", name: "DMRs", bedItems: dmrBedItems });
+    tklst.push({ type: "bedj", name: "Sig. CpGs", bedItems: sigCpgBedItems });
+    if (betaTrackImg) {
+      tklst.push({
+        type: "bigwig",
+        name: "Per-CpG Means",
+        height: 150,
+        imgData: betaTrackImg
+      });
+    }
+    return tklst;
+  }
+  buildLegendData(config, dmrs, sigCpgBedItems, showLoess, showDots, showCi) {
+    const { colors } = config.settings.dmr;
+    const g1 = config.group1Name || "Group 1";
+    const g2 = config.group2Name || "Group 2";
+    const meansItems = [];
+    if (showDots) {
+      meansItems.push({ text: `${g1} (control)`, color: colors.group1 }, { text: `${g2} (case)`, color: colors.group2 });
+    }
+    if (showLoess) {
+      const ciLabel = showCi ? " + 95% CI" : "";
+      meansItems.push(
+        { text: `${g1} LOESS trend${ciLabel}`, color: colors.group1, style: showCi ? "shaded" : "dashed" },
+        { text: `${g2} LOESS trend${ciLabel}`, color: colors.group2, style: showCi ? "shaded" : "dashed" }
+      );
+    }
+    const rows = [{ label: "Per-CpG Means", items: meansItems }];
+    const hasHyper = dmrs.some((d) => d.direction === "hyper");
+    const hasHypo = dmrs.some((d) => d.direction === "hypo");
+    if (hasHyper || hasHypo) {
+      const items = [];
+      if (hasHyper) items.push({ text: "Hypermethylated", color: colors.hyper });
+      if (hasHypo) items.push({ text: "Hypomethylated", color: colors.hypo });
+      rows.push({ label: "DMR", items });
+    }
+    if (sigCpgBedItems.length) {
+      const items = [];
+      const hasHyperCpg = sigCpgBedItems.some((b) => b.color === colors.hyper);
+      const hasHypoCpg = sigCpgBedItems.some((b) => b.color === colors.hypo);
+      if (hasHyperCpg) items.push({ text: "Hyper (FDR sig.)", color: colors.hyper });
+      if (hasHypoCpg) items.push({ text: "Hypo (FDR sig.)", color: colors.hypo });
+      rows.push({ label: "Sig. CpGs", items });
+    }
+    return rows;
+  }
+  /**
+   * Render the per-CpG means scatter plot to an offscreen canvas and return
+   * a data URI suitable for the bigwig imgData track.
+   */
+  renderBetaTrack(diagnostic, config, blockWidth, showLoess, showDots, queryStart, queryStop) {
+    const { probes } = diagnostic;
+    if (!probes.positions.length) return void 0;
+    const { colors, fdr_cutoff, minProbesForCi } = config.settings.dmr;
+    const dpr = typeof window !== "undefined" && window.devicePixelRatio > 1 ? window.devicePixelRatio : 1;
+    const width = blockWidth;
+    const height = 150;
+    const canvas = document.createElement("canvas");
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return void 0;
+    ctx.scale(dpr, dpr);
+    const xMin = queryStart ?? probes.positions[0];
+    const xMax = queryStop ?? probes.positions[probes.positions.length - 1];
+    const xRange = xMax - xMin || 1;
+    const scaleX = (val) => (val - xMin) / xRange * width;
+    const scaleY = (val) => height - val * height;
+    ctx.clearRect(0, 0, width, height);
+    let showCi = false;
+    if (showLoess && diagnostic.loess) {
+      const { loess } = diagnostic;
+      const firstProbePos = probes.positions[0];
+      const lastProbePos = probes.positions[probes.positions.length - 1];
+      showCi = probes.positions.length >= minProbesForCi;
+      for (const [fitted, ciLower, ciUpper, color] of [
+        [loess.group1_fitted, loess.group1_ci_lower, loess.group1_ci_upper, colors.group1],
+        [loess.group2_fitted, loess.group2_ci_lower, loess.group2_ci_upper, colors.group2]
+      ]) {
+        if (!fitted.length) continue;
+        const lPos = loess.positions;
+        let iStart = 0;
+        let iEnd = lPos.length - 1;
+        while (iStart < lPos.length && lPos[iStart] < firstProbePos) iStart++;
+        while (iEnd >= 0 && lPos[iEnd] > lastProbePos) iEnd--;
+        if (iStart > iEnd) continue;
+        if (showCi) {
+          ctx.globalAlpha = 0.12;
+          ctx.fillStyle = color;
+          ctx.beginPath();
+          for (let i = iStart; i <= iEnd; i++) {
+            ctx.lineTo(scaleX(lPos[i]), scaleY(Math.max(0, Math.min(1, ciUpper[i]))));
+          }
+          for (let i = iEnd; i >= iStart; i--) {
+            ctx.lineTo(scaleX(lPos[i]), scaleY(Math.max(0, Math.min(1, ciLower[i]))));
+          }
+          ctx.closePath();
+          ctx.fill();
+        }
+        ctx.globalAlpha = 0.8;
+        ctx.strokeStyle = color;
+        ctx.lineWidth = 2;
+        ctx.setLineDash(showCi ? [] : [6, 4]);
+        ctx.beginPath();
+        for (let i = iStart; i <= iEnd; i++) {
+          ctx.lineTo(scaleX(lPos[i]), scaleY(Math.max(0, Math.min(1, fitted[i]))));
+        }
+        ctx.stroke();
+        ctx.setLineDash([]);
+      }
+    }
+    if (!showDots) {
+      ctx.globalAlpha = 1;
+      return { img: { minv: 0, maxv: 1, src: canvas.toDataURL("image/png") }, showCi };
+    }
+    for (let i = 0; i < probes.positions.length; i++) {
+      const x = scaleX(probes.positions[i]);
+      const isSig = probes.fdr[i] < fdr_cutoff;
+      const alpha = isSig ? 0.85 : 0.3;
+      ctx.globalAlpha = alpha;
+      ctx.fillStyle = colors.group1;
+      const m1 = probes.mean_group1[i];
+      if (m1 != null) {
+        ctx.beginPath();
+        ctx.arc(x, scaleY(m1), 4, 0, Math.PI * 2);
+        ctx.fill();
+      }
+      ctx.fillStyle = colors.group2;
+      const m2 = probes.mean_group2[i];
+      if (m2 != null) {
+        ctx.beginPath();
+        ctx.arc(x, scaleY(m2), 4, 0, Math.PI * 2);
+        ctx.fill();
+      }
+    }
+    ctx.globalAlpha = 1;
+    return { img: { minv: 0, maxv: 1, src: canvas.toDataURL("image/png") }, showCi };
+  }
+  makeDmrBedItems(dmrResult, settings) {
+    return dmrResult.dmrs.map((dmr) => {
+      const negLog = -Math.log10(Math.max(dmr.min_smoothed_fdr, 1e-300));
+      const alpha = Math.round(Math.min(255, Math.max(50, negLog / 10 * 255)));
+      const hex = alpha.toString(16).padStart(2, "0");
+      const base = dmr.direction === "hyper" ? settings.dmr.colors.hyper : settings.dmr.colors.hypo;
+      return { chr: dmr.chr, start: dmr.start, stop: dmr.stop, color: base + hex };
+    });
+  }
+  makeSigCpgBedItems(dmrResult, settings, chr, queryStart, queryStop) {
+    const diag = dmrResult.diagnostic;
+    if (!diag) return [];
+    const { probes } = diag;
+    const items = [];
+    const minDeltaBeta = 0.05;
+    for (let i = 0; i < probes.positions.length; i++) {
+      if (probes.fdr[i] >= settings.dmr.fdr_cutoff) continue;
+      const pos = probes.positions[i];
+      if (queryStart != null && queryStop != null && (pos < queryStart || pos > queryStop)) continue;
+      const mg1 = probes.mean_group1[i];
+      const mg2 = probes.mean_group2[i];
+      if (mg1 == null || mg2 == null) continue;
+      const deltaBeta = mg2 - mg1;
+      if (Math.abs(deltaBeta) < minDeltaBeta) continue;
+      const color = deltaBeta >= 0 ? settings.dmr.colors.hyper : settings.dmr.colors.hypo;
+      items.push({ chr, start: pos, stop: pos + 1, color });
+    }
+    return items;
+  }
+};
+
+export {
+  getDefaultDMRSettings,
+  CCRE_TRACK_NAME,
+  DmrViewModel
+};
+//# sourceMappingURL=chunk-JPRCZTWX.js.map