@sjcrh/proteinpaint-client 2.210.1 → 2.211.0

package/dist/chunk-6QMC7LFA.js

@@ -0,0 +1,299 @@
+import {
+  first_genetrack_tolist,
+  gmmode,
+  sayerror
+} from "./chunk-K7HFOAR7.js";
+import {
+  dofetch3
+} from "./chunk-GP4VLNMZ.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-E7YUGCHL.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-E7YUGCHL.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-6QMC7LFA.js.map

package/dist/chunk-6XKAOSQE.js

@@ -0,0 +1,116 @@
+// dom/numericRangeInput.ts
+var NumericRangeInput = class {
+  constructor(holder, range, callback, opts) {
+    this.scaleFactor = opts?.scaleFactor && opts.scaleFactor > 0 ? opts.scaleFactor : 1;
+    this.min = opts?.min;
+    this.max = opts?.max;
+    this.input = holder.append("input").attr("name", "rangeInput").attr("aria-label", "Leave blank for the allowed minimum value").style("width", opts?.width || "180px").style("margin", "3px 5px").on("change", () => {
+      try {
+        this.parseRange();
+      } catch (ex) {
+        alert(ex);
+        this.setRange();
+      }
+    });
+    this.setRange(range);
+    this.callback = callback;
+  }
+  getInput() {
+    return this.input;
+  }
+  parseRange() {
+    const str = this.input.node().value;
+    const new_range = toStoredUnits(parseRange(str), this.scaleFactor);
+    this.validateBounds(new_range);
+    this.range = new_range;
+    this.callback(new_range);
+    return new_range;
+  }
+  /** throws on a range that selects nothing within the allowed bounds. a bound at the min or max is
+   * allowed when inclusive, e.g. x>=1 for a fraction */
+  validateBounds(r) {
+    const min = this.min, max = this.max;
+    const minLabel = toDisplayValue(min, this.scaleFactor), maxLabel = toDisplayValue(max, this.scaleFactor);
+    if (r.value != void 0) {
+      if (min != void 0 && r.value < min) throw `Invalid value < minimum allowed (${minLabel})`;
+      if (max != void 0 && r.value > max) throw `Invalid value > maximum allowed (${maxLabel})`;
+      return;
+    }
+    if (min != void 0) {
+      if (!r.startunbounded && r.start < min) throw `Invalid start value < minimum allowed (${minLabel})`;
+      if (!r.stopunbounded && (r.stop < min || r.stop == min && !r.stopinclusive))
+        throw `Invalid stop value ${r.stopinclusive ? "<" : "<="} minimum allowed (${minLabel})`;
+    }
+    if (max != void 0) {
+      if (!r.stopunbounded && r.stop > max) throw `Invalid stop value > maximum allowed (${maxLabel})`;
+      if (!r.startunbounded && (r.start > max || r.start == max && !r.startinclusive))
+        throw `Invalid start value ${r.startinclusive ? ">" : ">="} maximum allowed (${maxLabel})`;
+    }
+  }
+  getRange() {
+    return this.range;
+  }
+  setRange(range) {
+    if (!range) range = this.range;
+    else this.range = range;
+    if (!range) return;
+    const [start, stop] = formatRangeBounds(range, this.scaleFactor);
+    this.input.node().value = range.value != void 0 ? ` x=${toDisplayValue(range.value, this.scaleFactor)} ` : `${start} x ${stop}`;
+  }
+};
+function toStoredUnits(range, scaleFactor) {
+  if (scaleFactor == 1) return range;
+  for (const k of ["start", "stop", "value"]) {
+    if (Number.isFinite(range[k])) range[k] = range[k] / scaleFactor;
+  }
+  return range;
+}
+function toDisplayValue(v, scaleFactor) {
+  if (scaleFactor == 1 || !Number.isFinite(Number(v))) return v;
+  return Number((Number(v) * scaleFactor).toFixed(2));
+}
+function formatRangeBounds(range, scaleFactor = 1) {
+  const startV = toDisplayValue(range.start, scaleFactor);
+  const stopV = toDisplayValue(range.stop, scaleFactor);
+  const start = range.startunbounded || range.start == void 0 ? "" : `${startV} ${range.startinclusive ? "<=" : "<"}`;
+  const stop = range.stopunbounded || range.stop == void 0 ? "" : `${range.stopinclusive ? "<=" : "<"} ${stopV}`;
+  return [start, stop];
+}
+function parseRange(str) {
+  if (!str) throw "Empty range";
+  const tokens = str.replace(/\s/g, "").split("x");
+  let start, stop, startinclusive, stopinclusive, value;
+  if (tokens[0]) parseRangeToken(tokens[0]);
+  if (tokens[1]) parseRangeToken(tokens[1]);
+  if (value != void 0) return { value, label: `x = ${value}` };
+  const startunbounded = start === void 0;
+  const stopunbounded = stop === void 0;
+  if (!startunbounded && !stopunbounded && start > stop) throw "start must be lower than stop";
+  return { start, stop, value, startinclusive, stopinclusive, startunbounded, stopunbounded };
+  function parseRangeToken(rangeToken) {
+    const floatExpr = "[+-]?\\d+(\\.\\d+)?";
+    if (new RegExp(`^${floatExpr}<$`).test(rangeToken) || new RegExp(`^>${floatExpr}$`).test(rangeToken)) {
+      start = parseFloat(rangeToken.match(floatExpr));
+      startinclusive = false;
+    } else if (new RegExp(`^${floatExpr}<=$`).test(rangeToken) || new RegExp(`^>=${floatExpr}$`).test(rangeToken)) {
+      start = parseFloat(rangeToken.match(floatExpr));
+      startinclusive = true;
+    } else if (new RegExp(`^${floatExpr}>$`).test(rangeToken) || new RegExp(`^<${floatExpr}$`).test(rangeToken)) {
+      stop = parseFloat(rangeToken.match(floatExpr));
+      stopinclusive = false;
+    } else if (new RegExp(`^${floatExpr}>=$`).test(rangeToken) || new RegExp(`^<=${floatExpr}$`).test(rangeToken)) {
+      stop = parseFloat(rangeToken.match(floatExpr));
+      stopinclusive = true;
+    } else if (new RegExp(`^${floatExpr}=$`).test(rangeToken) || new RegExp(`^=${floatExpr}$`).test(rangeToken)) {
+      value = parseFloat(rangeToken.match(floatExpr));
+      stopinclusive = true;
+      startinclusive = true;
+    } else throw `Could not parse expression '${rangeToken}'`;
+  }
+}
+
+export {
+  NumericRangeInput,
+  formatRangeBounds
+};
+//# sourceMappingURL=chunk-6XKAOSQE.js.map

package/dist/chunk-6XKAOSQE.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../dom/numericRangeInput.ts"],
+  "sourcesContent": ["import type { Elem, Input } from '../types/d3'\nimport type { FullyBoundedBin } from '#types'\n\ntype TvsRange = FullyBoundedBin & { value?: number }\ntype Opts = {\n\twidth?: string // width of input\n\t/** multiplier from the unit a term's values are stored in to the unit shown to users, from\n\t * term.valueConversion (see getValueConversionFactor()). the range handed in and given back is\n\t * always in the stored unit; only the text in the <input> is in the user-facing one */\n\tscaleFactor?: number\n\t/** the allowed bounds of a typed range, in the stored unit, e.g. 0 and 1 for a fraction. kept apart\n\t * from the range, which is replaced by every parsed entry */\n\tmin?: number | null\n\tmax?: number | null\n}\n\nexport class NumericRangeInput {\n\tcallback: (f: any) => void\n\tinput: Input\n\trange: any\n\tscaleFactor: number\n\tmin?: number | null\n\tmax?: number | null\n\n\tconstructor(holder: Elem, range: any, callback: () => void, opts?: Opts) {\n\t\tthis.scaleFactor = opts?.scaleFactor && opts.scaleFactor > 0 ? opts.scaleFactor : 1\n\t\tthis.min = opts?.min\n\t\tthis.max = opts?.max\n\t\tthis.input = holder\n\t\t\t.append('input')\n\t\t\t.attr('name', 'rangeInput')\n\t\t\t.attr('aria-label', 'Leave blank for the allowed minimum value')\n\t\t\t.style('width', opts?.width || '180px')\n\t\t\t.style('margin', '3px 5px')\n\t\t\t//.style('font-size', '20px')\n\t\t\t.on('change', () => {\n\t\t\t\ttry {\n\t\t\t\t\tthis.parseRange()\n\t\t\t\t} catch (ex) {\n\t\t\t\t\talert(ex)\n\t\t\t\t\tthis.setRange()\n\t\t\t\t}\n\t\t\t})\n\t\tthis.setRange(range)\n\t\tthis.callback = callback\n\t}\n\n\tgetInput() {\n\t\treturn this.input\n\t}\n\n\tparseRange() {\n\t\tconst str = this.input.node()!.value\n\t\tconst new_range = toStoredUnits(parseRange(str), this.scaleFactor)\n\t\tthis.validateBounds(new_range)\n\t\tthis.range = new_range\n\t\tthis.callback(new_range)\n\t\treturn new_range\n\t}\n\n\t/** throws on a range that selects nothing within the allowed bounds. a bound at the min or max is\n\t * allowed when inclusive, e.g. x>=1 for a fraction */\n\tvalidateBounds(r: any) {\n\t\tconst min = this.min,\n\t\t\tmax = this.max\n\t\tconst minLabel = toDisplayValue(min, this.scaleFactor),\n\t\t\tmaxLabel = toDisplayValue(max, this.scaleFactor)\n\t\tif (r.value != undefined) {\n\t\t\tif (min != undefined && r.value < min) throw `Invalid value < minimum allowed (${minLabel})`\n\t\t\tif (max != undefined && r.value > max) throw `Invalid value > maximum allowed (${maxLabel})`\n\t\t\treturn\n\t\t}\n\t\tif (min != undefined) {\n\t\t\tif (!r.startunbounded && r.start < min) throw `Invalid start value < minimum allowed (${minLabel})`\n\t\t\tif (!r.stopunbounded && (r.stop < min || (r.stop == min && !r.stopinclusive)))\n\t\t\t\tthrow `Invalid stop value ${r.stopinclusive ? '<' : '<='} minimum allowed (${minLabel})`\n\t\t}\n\t\tif (max != undefined) {\n\t\t\tif (!r.stopunbounded && r.stop > max) throw `Invalid stop value > maximum allowed (${maxLabel})`\n\t\t\tif (!r.startunbounded && (r.start > max || (r.start == max && !r.startinclusive)))\n\t\t\t\tthrow `Invalid start value ${r.startinclusive ? '>' : '>='} maximum allowed (${maxLabel})`\n\t\t}\n\t}\n\n\tgetRange() {\n\t\treturn this.range\n\t}\n\n\tsetRange(range?: TvsRange) {\n\t\tif (!range) range = this.range\n\t\t//When an error is thrown the previous range is restored\n\t\telse this.range = range\n\n\t\t//So ts doesn't complain\n\t\tif (!range) return\n\t\tconst [start, stop] = formatRangeBounds(range, this.scaleFactor)\n\t\tthis.input.node()!.value =\n\t\t\trange.value != undefined ? ` x=${toDisplayValue(range.value, this.scaleFactor)} ` : `${start} x ${stop}`\n\t}\n}\n\n/** convert a range parsed from the <input> text back to the unit its values are stored in */\nfunction toStoredUnits(range: any, scaleFactor: number) {\n\tif (scaleFactor == 1) return range\n\tfor (const k of ['start', 'stop', 'value']) {\n\t\tif (Number.isFinite(range[k])) range[k] = range[k] / scaleFactor\n\t}\n\treturn range\n}\n\n/** a converted value is rounded, so that an input does not read 70.81451060916.\n * this makes the round trip through parseRange() lossy by up to half of the last shown digit,\n * which is immaterial for a filter range */\nfunction toDisplayValue(v: any, scaleFactor: number) {\n\tif (scaleFactor == 1 || !Number.isFinite(Number(v))) return v\n\treturn Number((Number(v) * scaleFactor).toFixed(2))\n}\n\n/** Format the start and stop of a range as displayed to the user, e.g. ['10 <', '<= 20'].\n *\n * A bound is exclusive unless the range marks it inclusive, matching how a range is\n * evaluated elsewhere, e.g. isInRange() on the server and the tvs pill label. The displayed\n * expression must round-trip through parseRange(), since the input text is the only source\n * of the applied range: rendering an exclusive bound as inclusive would silently widen a\n * saved range on apply.\n */\nexport function formatRangeBounds(range: any, scaleFactor = 1): [string, string] {\n\tconst startV = toDisplayValue(range.start, scaleFactor)\n\tconst stopV = toDisplayValue(range.stop, scaleFactor)\n\tconst start = range.startunbounded || range.start == undefined ? '' : `${startV} ${range.startinclusive ? '<=' : '<'}`\n\tconst stop = range.stopunbounded || range.stop == undefined ? '' : `${range.stopinclusive ? '<=' : '<'} ${stopV}`\n\treturn [start, stop]\n}\n\nexport function parseRange(str: string) {\n\tif (!str) throw 'Empty range'\n\tconst tokens = str.replace(/\\s/g, '').split('x')\n\tlet start, stop, startinclusive, stopinclusive, value\n\n\tif (tokens[0]) parseRangeToken(tokens[0])\n\tif (tokens[1]) parseRangeToken(tokens[1])\n\tif (value != undefined) return { value, label: `x = ${value}` }\n\tconst startunbounded = start === undefined\n\tconst stopunbounded = stop === undefined\n\n\tif (!startunbounded && !stopunbounded && start > stop) throw 'start must be lower than stop'\n\treturn { start, stop, value, startinclusive, stopinclusive, startunbounded, stopunbounded }\n\n\tfunction parseRangeToken(rangeToken) {\n\t\tconst floatExpr = '[+-]?\\\\d+(\\\\.\\\\d+)?'\n\n\t\tif (new RegExp(`^${floatExpr}<$`).test(rangeToken) || new RegExp(`^>${floatExpr}$`).test(rangeToken)) {\n\t\t\tstart = parseFloat(rangeToken.match(floatExpr))\n\t\t\tstartinclusive = false\n\t\t} else if (new RegExp(`^${floatExpr}<=$`).test(rangeToken) || new RegExp(`^>=${floatExpr}$`).test(rangeToken)) {\n\t\t\tstart = parseFloat(rangeToken.match(floatExpr))\n\t\t\tstartinclusive = true\n\t\t} else if (new RegExp(`^${floatExpr}>$`).test(rangeToken) || new RegExp(`^<${floatExpr}$`).test(rangeToken)) {\n\t\t\tstop = parseFloat(rangeToken.match(floatExpr))\n\t\t\tstopinclusive = false\n\t\t} else if (new RegExp(`^${floatExpr}>=$`).test(rangeToken) || new RegExp(`^<=${floatExpr}$`).test(rangeToken)) {\n\t\t\tstop = parseFloat(rangeToken.match(floatExpr))\n\t\t\tstopinclusive = true\n\t\t} else if (new RegExp(`^${floatExpr}=$`).test(rangeToken) || new RegExp(`^=${floatExpr}$`).test(rangeToken)) {\n\t\t\tvalue = parseFloat(rangeToken.match(floatExpr))\n\t\t\tstopinclusive = true\n\t\t\tstartinclusive = true\n\t\t} else throw `Could not parse expression '${rangeToken}'`\n\t}\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/chunk-72L6NTNT.js

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

package/dist/chunk-7ISAV37C.js

@@ -0,0 +1,194 @@
+import {
+  sample_match_termvaluesetting
+} from "./chunk-DD3DWHUY.js";
+import {
+  isDictionaryType
+} from "./chunk-CME6DYDH.js";
+import {
+  __export
+} from "./chunk-HS5PO5ZQ.js";
+
+// plots/matrix/matrix.data.js
+var matrix_data_exports = {};
+__export(matrix_data_exports, {
+  applyLegendValueFilter: () => applyLegendValueFilter,
+  getMatrixRequestOpts: () => getMatrixRequestOpts,
+  mayRequireToken: () => mayRequireToken,
+  setData: () => setData
+});
+function mayRequireToken(tokenMessage = "") {
+  const message = tokenMessage || this.state.tokenVerificationMessage;
+  if (!message && this.state.hasVerifiedToken) {
+    this.dom.errdiv.style("display", "none").html();
+    this.dom.controls.style("display", this.opts.controls ? "inline-block" : "");
+    this.dom.svg.style("display", "");
+    return false;
+  } else {
+    this.dom.errdiv.style("display", "").html(message || "Requires login");
+    this.dom.controls.style("display", "none");
+    this.dom.svg.style("display", "none");
+    return true;
+  }
+}
+function getMatrixRequestOpts(state, config) {
+  const terms = [];
+  const termgroups = this.chartType == "hierCluster" ? config.termgroups.filter((grp) => grp.type != "hierCluster") : config.termgroups;
+  for (const grp of termgroups) {
+    terms.push(...getNormalizedTwLstCopy(grp.lst));
+  }
+  if (config.divideBy) terms.push(normalizeTwForRequest(structuredClone(config.divideBy)));
+  const opts = {
+    terms,
+    filter: state.filter,
+    filter0: state.filter0,
+    maxGenes: state.config.settings.matrix.maxGenes,
+    /*********** quick fix
+    when the flag is true, set artificially large number to ensure all genes are sent in one query
+    this avoids changing getAnnotatedSampleData()
+    additional non-matrix app that calls getAnnotatedSampleData will NEED THE SAME FIX
+    */
+    termsPerRequest: this.app.vocabApi.termdbConfig.queries?.snvindel?.byisoform?.processTwsInOneQuery ? 1e3 : 1
+  };
+  if (this.chartType == "hierCluster") {
+    opts.isHierCluster = 1;
+  }
+  return opts;
+}
+function getNormalizedTwLstCopy(twlst) {
+  const lst = [];
+  for (const tw of twlst) {
+    if (tw.type && tw.constructor.name != "Object") lst.push(tw);
+    else lst.push(normalizeTwForRequest(tw));
+  }
+  lst.forEach(normalizeTwForRequest);
+  lst.sort(sortTwLst);
+  return lst;
+}
+function normalizeTwForRequest(_tw) {
+  const tw = structuredClone(_tw);
+  if (!tw?.term) return;
+  delete tw.term.category2samplecount;
+  if (isDictionaryType(tw.term.type) && tw.term.type !== "samplelst") delete tw.term.values;
+  return tw;
+}
+function sortTwLst(twa, twb) {
+  const a = twa?.$id || twa.term?.id || twa?.term?.name;
+  const b = twb?.$id || twb.term?.id || twb?.term?.name;
+  return a < b ? -1 : 1;
+}
+async function setData(_data) {
+  const opts = this.currRequestOpts?.matrix || this.getMatrixRequestOpts(this.state, this.config);
+  this.numTerms = opts.terms.length;
+  opts.loadingDiv = this.chartType != "hierCluster" && this.dom.loadingDiv;
+  opts.signal = this.api.getAbortSignal();
+  const data = await this.app.vocabApi.getAnnotatedSampleData(opts, _data);
+  this.data = data;
+  this.origData = structuredClone(this.data);
+  this.sampleIdMap = {};
+  for (const d of this.data.lst) {
+    this.sampleIdMap[d.sample] = d._ref_.label;
+  }
+}
+function applyLegendValueFilter() {
+  const self = this;
+  if (!self.config.legendValueFilter.lst.length && !self.config.legendGrpFilter.lst.length) return;
+  for (const grpFilter of self.config.legendGrpFilter.lst) {
+    if (grpFilter.dt) {
+      const filteredOutCats = /* @__PURE__ */ new Set();
+      for (const oneSampleData of self.origData.lst) {
+        for (const annoForOneTerm of Object.values(oneSampleData)) {
+          if (annoForOneTerm.values) {
+            const newValues = [];
+            for (const v of annoForOneTerm.values) {
+              if (!(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))) {
+                newValues.push(v);
+              } else {
+                filteredOutCats.add(v.class);
+              }
+            }
+            annoForOneTerm.values = newValues;
+          }
+        }
+      }
+      grpFilter.filteredOutCats = [...filteredOutCats];
+      for (const oneSampleData of Object.values(self.origData.samples)) {
+        for (const annoForOneTerm of Object.values(oneSampleData)) {
+          if (annoForOneTerm.values)
+            annoForOneTerm.values = annoForOneTerm.values.filter(
+              (v) => !(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))
+            );
+        }
+      }
+    }
+  }
+  const geneVariant$ids = Object.values(self.data.refs.byTermId).filter((v) => v.term?.type == "geneVariant").map((v) => v.$id);
+  const data = { samples: {}, lst: [], refs: self.data.refs };
+  const onlyHardFilter = structuredClone(self.config.legendValueFilter);
+  onlyHardFilter.lst = onlyHardFilter.lst.filter(
+    (l) => !l.tvs.legendFilterType || l.tvs.legendFilterType !== "geneVariant_soft"
+  );
+  for (const row of self.origData.lst) {
+    const include = sample_match_termvaluesetting(row, onlyHardFilter, geneVariant$ids);
+    if (include || self.chartType == "hierCluster") {
+      data.samples[row.sample] = row;
+      data.lst.push(row);
+    }
+  }
+  for (const valFilter of self.config.legendValueFilter.lst) {
+    if (valFilter.tvs.legendFilterType !== "geneVariant_soft") continue;
+    const tvsV = valFilter.tvs.values[0];
+    const filteredOutCats = /* @__PURE__ */ new Set();
+    for (const oneSampleData of data.lst) {
+      for (const annoForOneTerm of Object.values(oneSampleData)) {
+        if (annoForOneTerm.values) {
+          const newValues = [];
+          for (const v of annoForOneTerm.values) {
+            if (!(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))) {
+              newValues.push(v);
+            } else {
+              filteredOutCats.add(v.class);
+            }
+          }
+          annoForOneTerm.values = newValues;
+        }
+      }
+    }
+    valFilter.filteredOutCats = [...filteredOutCats];
+    for (const oneSampleData of Object.values(data.samples)) {
+      for (const annoForOneTerm of Object.values(oneSampleData)) {
+        if (annoForOneTerm.values)
+          annoForOneTerm.values = annoForOneTerm.values.filter(
+            (v) => !(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))
+          );
+      }
+    }
+  }
+  if (self.chartType !== "hierCluster" && geneVariant$ids.length && self.app.vocabApi.termdbConfig?.matrix?.removeEmptySamples)
+    remove_empty_sample(data, geneVariant$ids);
+  self.data = data;
+}
+function remove_empty_sample(data) {
+  for (const oneSampleData of data.lst) {
+    let removeSample = true;
+    for (const [key, annoForOneTerm] of Object.entries(oneSampleData)) {
+      if (!annoForOneTerm.values) continue;
+      const annoType = data.refs.byTermId[key].term.type;
+      if (annoType != "geneVariant") continue;
+      if (annoForOneTerm.values.length) removeSample = false;
+    }
+    if (removeSample) {
+      data.lst = data.lst.filter((dl) => dl.sample !== oneSampleData.sample);
+      delete data.samples[parseInt(oneSampleData.sample)];
+    }
+  }
+  return data;
+}
+
+export {
+  mayRequireToken,
+  getMatrixRequestOpts,
+  setData,
+  applyLegendValueFilter,
+  matrix_data_exports
+};
+//# sourceMappingURL=chunk-7ISAV37C.js.map