@sjcrh/proteinpaint-client 2.195.0 → 2.196.0

package/dist/chunk-CDJAHMAN.js

@@ -0,0 +1,299 @@
+import {
+  first_genetrack_tolist,
+  gmmode,
+  sayerror
+} from "./chunk-WY2PGUVX.js";
+import {
+  dofetch3
+} from "./chunk-LYVLF6HO.js";
+import {
+  codon_stop,
+  nt2aa,
+  proteinDomainColorScale
+} from "./chunk-7KRS7L4U.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-YPM767A4.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-TNIIJABK.js");
+      _.validate_oldds(ds);
+      delete ds.legacyDsIsUninitiated;
+    }
+  }
+  const b = await import("./block-YPM767A4.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-CDJAHMAN.js.map

package/dist/chunk-CXHLROWX.js

@@ -0,0 +1,37 @@
+import {
+  addGeneSearchbox,
+  getGEunit
+} from "./chunk-WY2PGUVX.js";
+import {
+  Menu
+} from "./chunk-HYOEWQ5P.js";
+import {
+  TermTypes
+} from "./chunk-NNFAUP2I.js";
+
+// termdb/handlers/geneExpression.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 geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: holder,
+      searchOnly: "gene",
+      callback: () => this.selectGene(geneSearch.geneSymbol)
+    });
+  }
+  async selectGene(gene) {
+    const unit = getGEunit(this.app.vocabApi);
+    const name = `${gene} ${unit}`;
+    if (!gene) throw new Error("No gene selected");
+    this.callback({ gene, name, type: TermTypes.GENE_EXPRESSION });
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-CXHLROWX.js.map

package/dist/chunk-ECIBJXFT.js

@@ -0,0 +1,352 @@
+import {
+  StoreBase,
+  getAppInit,
+  getStoreInit
+} from "./chunk-M3J4MINX.js";
+
+// test/Locator.ts
+var Locator = class _Locator {
+  // arg could be one of the following, must always
+  // - DOM element
+  // - string selector
+  // - d3-selection
+  constructor(arg, opts = {}) {
+    //HTMLElement | SVGElement | SVGGElement | SVGLineElement | SVGRectElement | SVGSVGElement | SVGTextElement
+    this.opts = {
+      intervalWait: 25,
+      maxWait: 3e3
+    };
+    this.pending = [];
+    this.result = [];
+    Object.assign(this.opts, opts);
+    this.setRoot(arg);
+  }
+  // convenience method to allow await Locator.init(elem).whenVisible('')
+  static init(elem) {
+    return new _Locator(elem);
+  }
+  setRoot(arg) {
+    if (typeof arg == "string") {
+      const node = document.body.querySelector(arg);
+      if (!node) throw `missing elem by selector='${arg}'`;
+      this.rootElem = node;
+    } else if (typeof arg.node == "function") {
+      const numMatch = arg.size();
+      if (!numMatch) throw `missing elem from d3-selection`;
+      this.rootElem = arg.node();
+    } else {
+      this.rootElem = arg;
+    }
+    this.pending = [];
+  }
+  root(arg) {
+    if (arg) this.setRoot(arg);
+    return this.rootElem;
+  }
+  // selector: string selector such as '#my-id', '.my-class', `[data-testid='my-id-here']`, `[role='button']`, etc
+  shows(selector, opts = {}) {
+    this.pending.push([
+      shows,
+      {
+        selector,
+        targetCount: opts.count || 1,
+        //'>=1',
+        visibility: opts.visibility ?? true,
+        intervalWait: opts.intervalWait || this.opts.intervalWait,
+        maxWait: opts.maxWait || this.opts.maxWait,
+        attr: opts.attr || {}
+      }
+    ]);
+    return this;
+  }
+  // same argument as this.shows(), but visibility is not checked
+  // and assumes that the elements targeted by the selector are
+  // ready to be queried
+  find(selector) {
+    this.pending.push([find, { selector }]);
+    return this;
+  }
+  // cannot chain another method after get(), since
+  // the retured promise would require wrapping in parentheses
+  //
+  // get()
+  // - run the pending functions in sequence and return the resolved
+  //   queried elems or its properties based on the argument
+  //
+  // Arguments:
+  //  arg: undefined | string | number | callback
+  //
+  // returns
+  //  - no argument: get the matched elements as an array
+  //  - callback function: passes the matched elements to the callback and returns its returned value
+  //  - number: use as index key to return elems[index]
+  //  - string: see the processing in the
+  async get(arg) {
+    const pending = this.pending;
+    this.pending = [];
+    let elems = [this.rootElem];
+    for (const [fxn, opts] of pending) {
+      elems = await fxn(elems, opts);
+    }
+    if (!arguments.length || arg === void 0) return elems;
+    if (typeof arg === "function") return arg(elems);
+    if (typeof arg === "number") return elems[arg];
+    if (typeof arg === "string") {
+      if (arg == "length") return elems.length;
+      const key = arg.slice(1);
+      if (!key) return elems;
+      const char = arg[0];
+      if (char === ".") return elems.map((elem) => elem[key]);
+      if (char === "@") return elems.map((elem) => elem.getAttribute(key));
+      if (char === ":") return elems.map((elem) => elem.style[key]);
+    }
+    throw `invalid Locator.get() argument='${arg}'`;
+  }
+  // propName: string property name, can be dot-separated like 'style.padding'
+  // value: string, number, boolean, any valid value for the given property name
+  async set(propName, value2) {
+    if (!propName) throw `invalid Locator.set() propName='${propName}'`;
+    const keyChain = propName.split(".");
+    const lastKey = keyChain.pop();
+    if (!lastKey) throw `invalid Locator.set() propName='${propName}'`;
+    const elems = await this.get();
+    for (const elem of elems) {
+      let obj = elem;
+      for (const key of keyChain) obj = obj[key];
+      obj[lastKey] = value2;
+    }
+    return elems;
+  }
+  /*** convenient aliased methods for .get(arg) ***/
+  async length() {
+    return await this.get("length");
+  }
+  async value(val) {
+    if (arguments.length) return await this.set("value", val);
+    return await this.get(".value");
+  }
+  async text(str) {
+    if (arguments.length) return await this.set("innerText", str);
+    return await this.get(".innerText");
+  }
+  hides(selector) {
+    return this.shows(selector, { visibility: false });
+  }
+  async click(arg) {
+    const elems = await this.get(arg);
+    const arr = Array.isArray(elems) ? elems : [elems];
+    for (const elem of arr) {
+      const box = elem.getBoundingClientRect();
+      const clientX = box.x + 0.5 * box.width;
+      const clientY = box.y + box.height;
+      elem.dispatchEvent(new MouseEvent("click", { bubbles: true, clientX, clientY }));
+    }
+    return elems;
+  }
+};
+async function shows(elems, opts) {
+  return new Promise((resolve) => {
+    const { selector, targetCount, intervalWait, maxWait, visibility, attr } = opts;
+    const matchedElems = /* @__PURE__ */ new Set();
+    let elapsed = 0, pending = false;
+    const i = setInterval(() => {
+      if (pending) return;
+      pending = true;
+      for (const elem of elems) {
+        for (const descendant of elem.querySelectorAll(selector)) {
+          if (matchedElems.has(descendant)) continue;
+          if (descendant.checkVisibility() === visibility) {
+            if (!attr) matchedElems.add(descendant);
+            else {
+              const kvEntries = Object.entries(attr);
+              const matchedKeys = [];
+              for (const [key, value2] of kvEntries) {
+                if (elem.getAttribute(key) !== value2) matchedKeys.push(key);
+              }
+              if (matchedKeys.length === kvEntries.length) matchedElems.add(descendant);
+            }
+          }
+        }
+      }
+      elapsed += intervalWait;
+      if (matchedElems.size >= targetCount || elapsed > maxWait) {
+        clearInterval(i);
+        resolve([...matchedElems]);
+      }
+      pending = false;
+    }, intervalWait);
+  });
+}
+async function find(elems, opts) {
+  for (const elem of elems) {
+    const match = elem.querySelector(opts.selector);
+    if (match) {
+      return [match];
+    }
+  }
+  return [];
+}
+
+// test/test.helpers.js
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function detectLst(_opts = {}) {
+  const defaults = {
+    target: _opts.target || _opts.elem,
+    selector: _opts.selector,
+    maxTime: 12e3,
+    // default is increased from 5 to 12 specifically for gdc live tests with high latency
+    observe: {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      characterData: true
+    }
+  };
+  if (!_opts.matcher) {
+    defaults.count = 1;
+    defaults.matchAs = "=";
+  }
+  const opts = Object.assign(defaults, _opts);
+  if (!opts.target) throw `missing opts.target (alias for opts.elem)`;
+  if (!opts.trigger && opts.count > 0) await sleep(0);
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    if (!opts.matcher && opts.selector) {
+      const elems = opts.target.querySelectorAll(opts.selector);
+      const matched = matchedCount(elems.length, opts);
+      if (matched) {
+        resolve([...elems]);
+        return;
+      }
+    }
+    const callback = (mutations) => {
+      const elems = opts.selector ? [...opts.target.querySelectorAll(opts.selector)] : [opts.target];
+      const mutated = mutations.filter((m) => elems.includes(m.target));
+      if (!mutated.length && opts.count !== 0) return;
+      const matched = opts.matcher ? opts.matcher(mutated, observer) : matchedCount(elems.length, opts);
+      const expired = Date.now() - start > opts.maxTime;
+      if (matched || expired) {
+        observer.disconnect();
+        if (t) clearTimeout(t);
+        if (matched) resolve(Array.isArray(matched) ? matched : elems);
+        else reject(`test exceeded maxTime=${opts.maxTime}`);
+      }
+    };
+    const observer = new MutationObserver(callback);
+    observer.observe(opts.target, opts.observe);
+    let t;
+    if (opts.maxTime) {
+      t = setTimeout(() => {
+        if (opts.count === 0) {
+        } else reject(`the elem '${opts.target}' did not render within ${opts.maxTime} milliseconds`);
+      }, opts.maxTime);
+    }
+    if (opts.trigger) opts.trigger();
+  });
+}
+function matchedCount(actual, opts) {
+  const expected = opts.count;
+  switch (opts.matchAs) {
+    case "=":
+      return actual === expected;
+    case "<":
+      return actual < expected;
+    case "<=":
+      return actual <= expected;
+    case ">":
+      return actual > expected;
+    case ">=":
+      return actual >= expected;
+    default:
+      throw `unknown matchAs='${opts.matchAs}'`;
+  }
+}
+async function detectStyle(opts) {
+  if (!opts.observe) opts.observe = {};
+  opts.observe.attributes = true;
+  opts.observe.attributeFilter = ["style"];
+  const lst = await detectLst(opts);
+  return lst;
+}
+async function detectGt(opts) {
+  opts.matchAs = ">";
+  const lst = await detectLst(opts);
+  return lst;
+}
+async function detectGte(opts) {
+  opts.matchAs = ">=";
+  const lst = await detectLst(opts);
+  return lst;
+}
+async function detectOne(opts) {
+  opts.count = 1;
+  const lst = await detectLst(opts);
+  return lst[0];
+}
+async function whenVisible(elem, opts = {}) {
+  const intervalWait = 25;
+  const totalWait = opts.wait || 5e3;
+  const numRepeats = totalWait / intervalWait;
+  return new Promise((resolve, reject) => {
+    let j = 0;
+    const i = setInterval(() => {
+      if (elem.style.display != "none") {
+        clearInterval(i);
+        resolve(elem);
+      } else {
+        j++;
+        if (j > numRepeats) {
+          reject(`elem did not become visible within 5 seconds`);
+          clearInterval(i);
+        }
+      }
+    }, intervalWait);
+  });
+}
+var TestAppStore = class _TestAppStore extends StoreBase {
+  static type = "store";
+  constructor(opts) {
+    super(opts);
+    this.type = _TestAppStore.type;
+    this.defaultState = {
+      debug: true
+    };
+  }
+  async init() {
+  }
+};
+var storeInit = getStoreInit(TestAppStore);
+var TestApp = class {
+  static type = "app";
+  constructor(opts) {
+    this.type = "app";
+    this.opts = opts;
+    this.fetchOpts = opts.fetchOpts;
+  }
+  async init() {
+    try {
+      this.store = await storeInit({ app: this.api, state: this.opts.state });
+      this.state = await this.store.copyState();
+      if (this.opts.dom) this.dom = this.opts.dom;
+      await this.api.dispatch();
+    } catch (e) {
+      if (e.stack) console.log(e.stack);
+      else throw `TestApp Error: ${e}`;
+    }
+  }
+};
+var testAppInit = getAppInit(TestApp);
+
+export {
+  Locator,
+  sleep,
+  detectLst,
+  detectStyle,
+  detectGt,
+  detectGte,
+  detectOne,
+  whenVisible
+};
+//# sourceMappingURL=chunk-ECIBJXFT.js.map