@sjcrh/proteinpaint-client 2.207.0 → 2.207.1

package/dist/chunk-Y4PX2ECH.js

@@ -0,0 +1,299 @@
+import {
+  first_genetrack_tolist,
+  gmmode,
+  sayerror
+} from "./chunk-PC4MFDHP.js";
+import {
+  dofetch3
+} from "./chunk-52QHIKH2.js";
+import {
+  codon_stop,
+  nt2aa,
+  proteinDomainColorScale
+} from "./chunk-RUBZCKIX.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-747IK2EW.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-747IK2EW.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-Y4PX2ECH.js.map

package/dist/chunk-YKM46UX5.js

@@ -0,0 +1,170 @@
+import {
+  getEmptyCell,
+  maySetEmptyCell,
+  setCellProps
+} from "./chunk-GVLWCGXX.js";
+import {
+  TermTypeGroups
+} from "./chunk-RUBZCKIX.js";
+import {
+  __export
+} from "./chunk-HS5PO5ZQ.js";
+
+// plots/matrix/matrix.serieses.js
+var matrix_serieses_exports = {};
+__export(matrix_serieses_exports, {
+  getSerieses: () => getSerieses
+});
+function getSerieses(data) {
+  const s = this.settings.matrix;
+  const serieses = [];
+  const { colw, dx, dy, xMin, xMax } = this.dimensions;
+  const dvt = this.config.divideBy || {};
+  const divideByTermId = "id" in dvt ? dvt.id : dvt.name;
+  const legendGroups = {};
+  this.colorScaleByTermId = {};
+  for (const t of this.termOrder) {
+    const $id = t.tw.$id;
+    const termid = "id" in t.tw.term ? t.tw.term.id : t.tw.term.name;
+    const isDivideByTerm = termid === divideByTermId;
+    const emptyGridCells = [];
+    const cellht = t.grp.type == "hierCluster" ? s.clusterRowh : dy;
+    const htAdjust = t.grp.type == "hierCluster" ? 0 : t.totalHtAdjustments;
+    const y = s.transpose ? 0 : t.totalIndex * cellht + t.visibleGrpIndex * s.rowgspace + htAdjust;
+    const twSpecificSettings = this.config.settings.matrix.twSpecificSettings;
+    const hoverY0 = (twSpecificSettings[$id]?.contBarGap || 0) + y;
+    const series = {
+      t,
+      tw: t.tw,
+      cells: [],
+      y,
+      hoverY0,
+      hoverY1: hoverY0 + (twSpecificSettings[$id]?.contBarH || cellht)
+    };
+    for (const so of this.unfilteredSampleOrder) {
+      const { totalIndex, grpIndex, row } = so;
+      series.x = !s.transpose ? 0 : t.totalIndex * dx + t.visibleGrpIndex * s.colgspace;
+      const anno = row[$id];
+      const cellTemplate = {
+        s: so,
+        sample: row.sample,
+        tw: t.tw,
+        term: t.tw.term,
+        termid,
+        $id,
+        totalIndex,
+        grpIndex,
+        row,
+        t,
+        seriesY: y
+      };
+      if (!anno) {
+        if (!so.grp.isExcluded && (s.useCanvas || so.grp)) {
+          const cell = getEmptyCell(cellTemplate, s, this.dimensions);
+          series.cells.push(cell);
+        }
+        continue;
+      }
+      const key = anno.key;
+      const values = anno.filteredValues || anno.values || [anno.value];
+      const numRects = s.cellEncoding == "oncoprint" ? 1 : values.length;
+      const height = !s.transpose ? s.rowh / numRects : colw;
+      const width = !s.transpose ? colw : colw / values.length;
+      const siblingCells = [];
+      if (!anno || !anno.renderedValues?.length) {
+        if (!so.grp.isExcluded && (s.useCanvas || so.grp)) {
+          const cell = getEmptyCell(cellTemplate, s, this.dimensions);
+          series.cells.push(cell);
+        }
+        continue;
+      }
+      for (const [i, value] of values.entries()) {
+        const cell = Object.assign({ key, siblingCells }, cellTemplate);
+        cell.valueIndex = i;
+        let legend;
+        if (typeof t.tw.setCellProps == "function") {
+          legend = t.tw.setCellProps(cell, anno, value, s, t, this, width, height, dx, dy, i);
+        } else {
+          const cellProps = t.grp.type == "hierCluster" ? setCellProps["hierCluster"] : t.tw.term.type == "samplelst" ? setCellProps["categorical"] : setCellProps[t.tw.term.type];
+          legend = cellProps(cell, t.tw, anno, value, s, t, this, width, height, dx, dy, i);
+        }
+        if (!s.useCanvas && (cell.x + cell.width < xMin || cell.x - cell.width > xMax)) continue;
+        if (legend) {
+          for (const l of [legendGroups, so.grp.legendGroups]) {
+            if (!l) continue;
+            if (!l[legend.group]) {
+              l[legend.group] = {
+                ref: legend.ref,
+                values: {},
+                order: legend.order,
+                $id,
+                origin: legend.entry.origin
+              };
+              if (legend.entry.dt) l[legend.group].dt = [legend.entry.dt];
+            }
+            const lg = l[legend.group];
+            if (lg.dt && !lg.dt.includes(legend.entry.dt)) lg.dt.push(legend.entry.dt);
+            const legendK = legend.entry.origin ? legend.entry.origin + legend.value : legend.value;
+            if (!lg.values[legendK]) {
+              lg.values[legendK] = JSON.parse(JSON.stringify(legend.entry));
+              if (legend.entry.scale) lg.values[legendK].scale = legend.entry.scale;
+            }
+            if (!lg.values[legendK].samples) lg.values[legendK].samples = /* @__PURE__ */ new Set();
+            if (t.tw.term.name === TermTypeGroups.MUTATION_SIGNATURE) {
+              if (value?.value > 0) lg.values[legendK].samples.add(row.sample);
+            } else lg.values[legendK].samples.add(row.sample);
+            if (isDivideByTerm) {
+              lg.values[legend.value].isExcluded = so.grp.isExcluded;
+            }
+          }
+        }
+        if (!so.grp.isExcluded) {
+          if (anno.renderedValues.includes(value)) series.cells.push(cell);
+          siblingCells.push(cell);
+        }
+      }
+      if (s.showGrid == "rect" && !so.grp.isExcluded) {
+        const cell = t.grp.type == "hierCluster" ? getEmptyCell(cellTemplate, s, this.dimensions) : maySetEmptyCell[t.tw.term.type]?.(siblingCells, cellTemplate, s, this.dimensions, this);
+        if (cell) emptyGridCells.push(cell);
+      }
+    }
+    if (emptyGridCells.length) series.cells.unshift(...emptyGridCells);
+    if (series.cells.length) serieses.push(series);
+  }
+  addAllHiddenLegendGroups(legendGroups, this);
+  this.legendData = this.getLegendData(legendGroups, data.refs, this);
+  for (const grp of this.sampleGroups) {
+    grp.legendData = this.getLegendData(grp.legendGroups, data.refs, this);
+  }
+  return serieses;
+}
+function addAllHiddenLegendGroups(legendGroups, self) {
+  for (const valueFilter of self.config.legendValueFilter.lst) {
+    if (valueFilter.tvs.term.type == "categorical" && !legendGroups[valueFilter.tvs.term.$id]) {
+      legendGroups[valueFilter.tvs.term.$id] = {
+        ref: {},
+        values: {},
+        $id: valueFilter.tvs.term.$id
+      };
+    } else if (valueFilter.tvs.term.type == "geneVariant" && !legendGroups[valueFilter.legendGrpName]) {
+      legendGroups[valueFilter.legendGrpName] = {
+        ref: {},
+        values: {},
+        dt: [valueFilter.tvs.values[0].dt],
+        origin: valueFilter.tvs.values[0].origin
+      };
+    } else if ((valueFilter.tvs.term.type == "integer" || valueFilter.tvs.term.type == "float") && !legendGroups[valueFilter.tvs.term.$id]) {
+      legendGroups[valueFilter.tvs.term.$id] = {
+        ref: {},
+        values: {},
+        $id: valueFilter.tvs.term.$id
+      };
+    }
+  }
+}
+
+export {
+  getSerieses,
+  matrix_serieses_exports
+};
+//# sourceMappingURL=chunk-YKM46UX5.js.map

package/dist/chunk-Z7AO6A7M.js

@@ -0,0 +1,14 @@
+// src/block.lazyload.js
+var Block;
+async function blocklazyload(arg) {
+  if (!Block) {
+    const b = await import("./block-747IK2EW.js");
+    Block = b.Block;
+  }
+  return new Block(arg);
+}
+
+export {
+  blocklazyload
+};
+//# sourceMappingURL=chunk-Z7AO6A7M.js.map

package/dist/chunk-ZENZ5H2Q.js

@@ -0,0 +1,49 @@
+import {
+  runproteinpaint
+} from "./chunk-LGR6CJTW.js";
+
+// test/front.helpers.js
+var serverData = /* @__PURE__ */ Object.create(null);
+function getRunPp(appname = "", defaultArgs = {}, _host = "http://localhost:3000") {
+  const host = window.testHost || _host;
+  const arg = {
+    host: window.testHost || _host,
+    noheader: 1,
+    nobox: true,
+    debug: 1,
+    norecover: true
+  };
+  if (appname == "mass" || appname == "termdb") {
+    defaultArgs.debounceInterval = 0;
+  }
+  if (appname) arg[appname] = defaultArgs;
+  else copyMerge(arg, defaultArgs);
+  const argStr = JSON.stringify(arg);
+  return function runpp(overrides = {}) {
+    const argCopy = JSON.parse(argStr);
+    if (appname) copyMerge(argCopy[appname], overrides);
+    else copyMerge(argCopy, overrides);
+    if (appname && defaultArgs.fetchOpts) {
+      argCopy[appname].fetchOpts = defaultArgs.fetchOpts;
+    }
+    return runproteinpaint(Object.assign(argCopy, { serverData }));
+  };
+}
+function copyMerge(base, ...args) {
+  const target = typeof base == "string" ? JSON.parse(base) : base;
+  for (const arg of args) {
+    if (arg) {
+      const source = typeof base == "string" ? JSON.parse(JSON.stringify(arg)) : arg;
+      for (const key in source) {
+        if (!target[key] || Array.isArray(target[key]) || typeof target[key] !== "object") target[key] = source[key];
+        else copyMerge(target[key], source[key]);
+      }
+    }
+  }
+  return target;
+}
+
+export {
+  getRunPp
+};
+//# sourceMappingURL=chunk-ZENZ5H2Q.js.map

package/dist/cohort-Q7TW5XTY.js

@@ -0,0 +1,70 @@
+import {
+  appInit,
+  vocabInit
+} from "./chunk-PC4MFDHP.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-HPAW7XDM.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-BZN2O76M.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-52QHIKH2.js";
+import "./chunk-A2ORIMUJ.js";
+import "./chunk-PPSWNLMG.js";
+import {
+  TermTypes
+} from "./chunk-RUBZCKIX.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// termdb/handlers/cohort.ts
+var SearchHandler = class {
+  init(opts) {
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    const cohorts = this.app.vocabApi.app?.opts?.opts?.cohorts0;
+    if (!cohorts?.length) return;
+    const terms = cohorts.map((cohort) => {
+      const term = {
+        id: cohort.id,
+        name: cohort.name,
+        type: TermTypes.COHORT,
+        filter0: cohort.filter,
+        isleaf: true,
+        parent_id: null
+      };
+      return term;
+    });
+    const vocabApi = vocabInit({ vocab: { terms } });
+    appInit({
+      holder,
+      vocabApi,
+      state: {
+        nav: { header_mode: "hide_search" }
+      },
+      tree: {
+        click_term: (term) => {
+          this.callback(term);
+        }
+      }
+    });
+  }
+};
+export {
+  SearchHandler
+};
+//# sourceMappingURL=cohort-Q7TW5XTY.js.map