@sjcrh/proteinpaint-client 2.221.0 → 2.222.0

package/dist/chunk-FRLAPBYW.js

@@ -0,0 +1,299 @@
+import {
+  first_genetrack_tolist,
+  gmmode,
+  sayerror
+} from "./chunk-4ASBDE27.js";
+import {
+  dofetch3
+} from "./chunk-4TJO2DGU.js";
+import {
+  codon_stop,
+  nt2aa,
+  proteinDomainColorScale
+} from "./chunk-WJLRU5OF.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-53QIZEH3.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-53QIZEH3.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-FRLAPBYW.js.map

package/dist/chunk-HKYUCYOQ.js

@@ -0,0 +1,266 @@
+import {
+  DATermTypes,
+  DMRCATE_DEFAULTS,
+  getOthersGroup
+} from "./chunk-4ASBDE27.js";
+import {
+  dofetch3
+} from "./chunk-4TJO2DGU.js";
+import {
+  DMR_SCAN_ELEMENT_TYPE
+} from "./chunk-WJLRU5OF.js";
+import {
+  rgb
+} from "./chunk-Q5RDQNIT.js";
+
+// plots/volcano/colors.ts
+function getGroupColors(config) {
+  const groups = config?.samplelst?.groups;
+  const termValues = config?.tw?.term?.values;
+  const rawDown = termValues?.[groups?.[0]?.name]?.color || "red";
+  const rawUp = termValues?.[groups?.[1]?.name]?.color || "blue";
+  return {
+    controlColor: toHex(rawDown, "red"),
+    caseColor: toHex(rawUp, "blue")
+  };
+}
+function toHex(color, fallback) {
+  const c = rgb(color || fallback);
+  return c.displayable() ? c.formatHex() : rgb(fallback).formatHex();
+}
+
+// plots/volcano/model/VolcanoModel.ts
+var VolcanoModel = class {
+  /** TODO: This model is used in both the volcano and gsea.
+   * In the future, create base model in DA and use specific
+   * classes for the volcano and gsea. */
+  constructor(plot, termType) {
+    this.plot = plot;
+    this.app = plot.app;
+    this.termType = termType;
+  }
+  /** May use mapper instead as more termTypes are added */
+  async getData(config, settings) {
+    this.config = config;
+    this.settings = settings;
+    if (this.termType === DATermTypes.GENE_EXPRESSION) {
+      const body = await this.getGERequestBody();
+      const response = await dofetch3("termdb/DE", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) {
+        response.daRequest = body;
+        this.setGroupSizes(response);
+      }
+      return response;
+    }
+    if (this.termType === DATermTypes.DNA_METHYLATION) {
+      const body = await this.getDMRequestBody();
+      const response = await dofetch3("termdb/diffMeth", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) {
+        response.daRequest = body;
+        this.setGroupSizes(response);
+      }
+      return response;
+    }
+    if (this.termType === DATermTypes.JUNCTION) {
+      const body = await this.getDSRequestBody();
+      const response = await dofetch3("termdb/diffSplice", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) {
+        response.daRequest = body;
+        this.setGroupSizes(response);
+      }
+      return response;
+    }
+    if (this.termType === DATermTypes.SINGLECELL_CELLTYPE) {
+      const body = await this.getSCCTRequestBody();
+      return await dofetch3("termdb/singlecellDEgenes", { body, signal: this.plot.api?.getAbortSignal() });
+    }
+    if (this.termType === DATermTypes.PROTEOME_DAP) {
+      const body = this.getDapRequestBody();
+      return await dofetch3("termdb/dapVolcano", { body, signal: this.plot.api?.getAbortSignal() });
+    }
+    if (this.termType === DATermTypes.SINGLECELL_GENE_EXPRESSION) {
+    }
+    throw new Error(`Volcano plot does not support route for termType='${this.termType}'`);
+  }
+  //Gene expression
+  async getGERequestBody() {
+    this.setOthersGroup(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DE",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      method: this.settings.method,
+      min_count: this.settings.minCount,
+      min_total_count: this.settings.minTotalCount,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      cpm_cutoff: this.settings.cpmCutoff,
+      volcanoRender: this.getVolcanoRender()
+    };
+    const pseudobulk = this.config.tw?.pseudobulk;
+    if (pseudobulk) body.pseudobulk = pseudobulk;
+    this.addConfounderTw(body);
+    return body;
+  }
+  //DNA methylation
+  async getDMRequestBody() {
+    this.setOthersGroup(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DM",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      min_samples_per_group: this.settings.minSamplesPerGroup,
+      exclude_sex_chr: this.settings.excludeSexChr,
+      /* Omitted rather than sent as 'promoter' when it is the default, so a request
+      from a promoter-only dataset is byte-identical to what this client sent before
+      the element picker existed. The server resolves an absent element_type to
+      'promoter'. This does NOT preserve cache keys -- the key object gained the
+      field server-side, so every pre-existing dm/ entry is orphaned on deploy
+      regardless of what the client sends. */
+      ...this.settings.elementType && this.settings.elementType != "promoter" ? { element_type: this.settings.elementType } : {},
+      // the scan's own knobs; the server ignores them for any other element type
+      ...this.settings.elementType == DMR_SCAN_ELEMENT_TYPE ? {
+        scan: {
+          ...this.settings.scanChromosome ? { chromosome: this.settings.scanChromosome } : {},
+          backgroundCorrection: !!this.settings.backgroundCorrection,
+          minCpgs: this.settings.minCpgs,
+          profileBinBp: this.settings.profileBinBp,
+          // only when changed: an explicit default would orphan every cached scan
+          ...this.settings.lambda != DMRCATE_DEFAULTS.lambda ? { lambda: this.settings.lambda } : {},
+          ...this.settings.C != DMRCATE_DEFAULTS.C ? { C: this.settings.C } : {},
+          ...this.settings.fdrCutoff != DMRCATE_DEFAULTS.fdrCutoff ? { fdrCutoff: this.settings.fdrCutoff } : {}
+        }
+      } : {},
+      volcanoRender: this.getVolcanoRender()
+    };
+    if (this.settings.elementType != DMR_SCAN_ELEMENT_TYPE) this.addConfounderTw(body);
+    return body;
+  }
+  //Splicing
+  async getDSRequestBody() {
+    this.setOthersGroup(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DS",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      method: this.settings.method,
+      /* leafcutter's own cluster filters, applied by the edgeR screen too so both engines
+      rank the same cluster set. Sent already scaled to cohort size by validateDSSettings --
+      as absolute counts they silently loosen as N grows. */
+      minSamplesPerIntron: this.settings.minSamplesPerIntron,
+      minSamplesPerGroup: this.settings.minSamplesPerGroup,
+      minCountsPerCluster: this.settings.minCountsPerCluster,
+      volcanoRender: this.getVolcanoRender()
+    };
+    this.addConfounderTw(body);
+    return body;
+  }
+  /** Parameters telling the server to run the `volcano` Rust renderer and return a
+   * volcano PNG + top-significant rows instead of the full dot list. */
+  getVolcanoRender() {
+    const dotRadius = Math.max(this.settings.width, this.settings.height) / 80;
+    const { caseColor, controlColor } = getGroupColors(this.config);
+    const useDeltaBeta = this.termType === DATermTypes.DNA_METHYLATION && this.settings.xAxis == "delta_beta";
+    const render = {
+      significanceThresholds: {
+        pValueCutoff: this.settings.pValue,
+        pValueType: this.settings.pValueType,
+        foldChangeCutoff: useDeltaBeta ? this.settings.deltaBetaCutoff : this.settings.foldChangeCutoff
+      },
+      ...useDeltaBeta ? { xField: "delta_beta" } : {},
+      // Tied to the delta-beta axis: the control that sets it is only offered for
+      // methylation, and centering a log2 fold-change axis is a different conversation.
+      ...useDeltaBeta && this.settings.centerDeltaBeta ? { centerX: true } : {},
+      pixelWidth: this.settings.width,
+      pixelHeight: this.settings.height,
+      colorSignificant: toHex(this.settings.defaultSignColor, "red"),
+      colorSignificantUp: caseColor,
+      colorSignificantDown: controlColor,
+      colorNonsignificant: toHex(this.settings.defaultNonSignColor, "black"),
+      dotRadius,
+      maxInteractiveDots: this.settings.maxInteractiveDots,
+      // Render the PNG at device-pixel resolution so it stays sharp on
+      // retina screens. The server reports the plot extent in CSS-space,
+      // so SVG overlay coords are unaffected.
+      //
+      // Oversample by 2× so the PNG also stays sharp when the user
+      // *zooms in after* the initial render (the captured DPR is frozen
+      // at fetch time — bigger headroom = more tolerable post-render
+      // zoom before pixelation appears). The server clamp keeps the
+      // bitmap memory bounded.
+      devicePixelRatio: (typeof window !== "undefined" ? window.devicePixelRatio : 1) * 2
+    };
+    if (this.termType === DATermTypes.JUNCTION) {
+      render.xField = "delta_psi";
+      render.significanceThresholds.foldChangeCutoff = this.settings.deltaPsiCutoff;
+    }
+    return render;
+  }
+  //This is a workaround until the server can accept an arr of confounder tws
+  addConfounderTw(body) {
+    const confounders = this.config?.confounderTws;
+    if (confounders?.length) {
+      body.tw = this.config.confounderTws[0];
+      if (confounders.length > 1) body.tw2 = this.config.confounderTws[1];
+    }
+  }
+  //Single cell cell type
+  getSCCTRequestBody() {
+    const body = {
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      sample: this.config.sample,
+      termId: this.config.termId,
+      categoryName: this.config.categoryName,
+      volcanoRender: this.getVolcanoRender()
+    };
+    return body;
+  }
+  getDapRequestBody() {
+    const { organism, assay, cohort } = this.config.proteomeDetails;
+    return {
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      organism,
+      assay,
+      cohort,
+      volcanoRender: this.getVolcanoRender()
+    };
+  }
+  /** The "others" group arrives as a placeholder with {in: false}. Replace it with the group that
+   * it stands for: the filter of the app without the samples of the other group, which the server
+   * resolves. */
+  setOthersGroup(samplelst) {
+    const i = samplelst.groups.findIndex((g) => !g.in);
+    if (i == -1) return;
+    const samplesGroup = samplelst.groups.find((g) => g.in);
+    samplelst.groups[i] = getOthersGroup(
+      { name: samplelst.groups[i].name, values: samplesGroup.values },
+      this.app.getState().termfilter
+    );
+  }
+  /** A group that the server resolved from a filter lists no sample here. Keep the number of its
+   * samples that the analysis ran on, where the group does not carry one, for getSampleNum(). */
+  setGroupSizes(response) {
+    for (const [i, g] of this.config.samplelst.groups.entries()) {
+      const n = response[`sample_size${i + 1}`];
+      if (!Array.isArray(g.values) && g.sampleCount === void 0 && Number.isFinite(n)) g.sampleCount = n;
+    }
+  }
+};
+
+export {
+  getGroupColors,
+  VolcanoModel
+};
+//# sourceMappingURL=chunk-HKYUCYOQ.js.map