@sjcrh/proteinpaint-client 2.225.0 → 2.227.0

package/dist/chunk-2IAELUCN.js

@@ -0,0 +1,348 @@
+import {
+  matchesGvQueryEntry
+} from "./chunk-CFYWQJ7F.js";
+import {
+  mclass
+} from "./chunk-2N345NXD.js";
+
+// ../shared/utils/dist/src/termCollection.js
+function validateTermCollectionTerm(term) {
+  if (!Array.isArray(term?.termlst) || !term.termlst.length)
+    throw new Error("termCollection requires nonempty term.termlst[]");
+  const memberIds = /* @__PURE__ */ new Set();
+  const types = /* @__PURE__ */ new Set();
+  for (const t of term.termlst) {
+    if (typeof t.id != "string" || !t.id) throw new Error("member term id not non-empty string");
+    if (typeof t.type != "string" || !t.type) throw new Error("member term type not non-empty string");
+    if (memberIds.has(t.id)) throw new Error(`duplicate member term id '${t.id}'`);
+    memberIds.add(t.id);
+    types.add(t.type == "integer" || t.type == "float" ? "numDict" : t.type);
+  }
+  if (types.size > 1) throw new Error("termCollection.termlst[] not allowed to mix multiple term types");
+  return memberIds;
+}
+function validateFractionMembers(numerators, denominators, memberIds) {
+  if (!Array.isArray(denominators) || !denominators.length) throw new Error("fraction requires nonempty denominators[]");
+  if (!Array.isArray(numerators) || !numerators.length) throw new Error("fraction requires nonempty numerators[]");
+  if (new Set(denominators).size !== denominators.length) throw new Error("fraction denominators[] contains duplicates");
+  if (new Set(numerators).size !== numerators.length) throw new Error("fraction numerators[] contains duplicates");
+  for (const id of denominators) {
+    if (typeof id != "string" || !id) throw new Error("fraction denominator id not non-empty string");
+    if (!memberIds.has(id)) throw new Error(`fraction denominator '${id}' is not a collection member`);
+  }
+  for (const id of numerators) {
+    if (typeof id != "string" || !id) throw new Error("fraction numerator id not non-empty string");
+    if (!denominators.includes(id)) throw new Error(`fraction numerator '${id}' is not included in denominators[]`);
+  }
+}
+var FRACTION_TW_TYPE = "TermCollectionTWFraction";
+function isFractionTw(tw) {
+  return tw?.type === FRACTION_TW_TYPE && tw?.term?.type === "termCollection";
+}
+function getFractionTvsTerm(tw) {
+  if (!isFractionTw(tw)) throw new Error("not a fraction termCollection tw");
+  const term = structuredClone(tw.term);
+  const memberIds = term.termlst?.length ? validateTermCollectionTerm(term) : new Set(term.termIds || []);
+  const denominators = tw.q?.denominators?.length ? [...tw.q.denominators] : [...memberIds];
+  const numerators = tw.q?.numerators?.length ? [...tw.q.numerators] : [...denominators];
+  validateFractionMembers(numerators, denominators, memberIds);
+  term.numerators = numerators;
+  term.denominators = denominators;
+  return term;
+}
+function validateTermCollectionFraction(q, term) {
+  const memberIds = validateTermCollectionTerm(term);
+  validateFractionMembers(q?.numerators, q?.denominators, memberIds);
+  if (q.mode === "discrete" && q.type !== "regular-bin" && q.type !== "custom-bin")
+    throw new Error("discrete fraction termCollection requires regular-bin or custom-bin q.type");
+}
+
+// ../shared/utils/dist/src/filter.js
+function getFilteredSamples(sampleAnno, filter) {
+  setDatasetAnnotations(filter);
+  const samples = /* @__PURE__ */ new Set();
+  for (const anno of sampleAnno) {
+    if (samples.has(anno.sample)) continue;
+    const data = anno.s || anno.data;
+    if (data && sample_match_termvaluesetting(data, filter)) {
+      samples.add(anno.sample);
+    }
+  }
+  return samples;
+}
+function sample_match_termvaluesetting(row, filter, _term = null, sample = null) {
+  const lst = filter.type == "tvslst" ? filter.lst : [filter];
+  let numberofmatchedterms = 0;
+  for (const item of lst) {
+    if ("type" in item && item.type == "tvslst") {
+      if (sample_match_termvaluesetting(row, item, _term, sample)) {
+        numberofmatchedterms++;
+      }
+    } else {
+      const itemCopy = JSON.parse(JSON.stringify(item));
+      const t = itemCopy.tvs;
+      if (_term && t.term) {
+        if (!(_term.name == t.term.name && _term.type == t.term.type)) {
+          numberofmatchedterms++;
+          continue;
+        }
+      }
+      let samplevalue;
+      if (_term && !t.term) {
+        if (t.term$type && t.term$type !== _term.type) {
+          numberofmatchedterms++;
+          continue;
+        }
+        t.term = _term;
+        samplevalue = typeof row === "object" && t.term.id in row ? row[t.term.id] : row;
+      } else if (sample && t.term.$id) {
+        samplevalue = sample[t.term.$id].value;
+      } else {
+        samplevalue = t.term.id in row ? row[t.term.id] : row;
+      }
+      setDatasetAnnotations(itemCopy);
+      let thistermmatch;
+      if (t.term.type == "categorical") {
+        if (samplevalue === void 0) continue;
+        thistermmatch = t.valueset.has(samplevalue);
+      } else if (t.term.type == "integer" || t.term.type == "float") {
+        if (samplevalue === void 0) continue;
+        for (const range of t.ranges) {
+          if ("value" in range) {
+            thistermmatch = samplevalue === range.value;
+            if (thistermmatch) break;
+          } else if (samplevalue == range.name) {
+            thistermmatch = true;
+            break;
+          } else {
+            if (t.term.values) {
+              const v = t.term.values[samplevalue.toString()];
+              if (v && v.uncomputable) {
+                continue;
+              }
+            }
+            let left, right;
+            if (range.startunbounded) {
+              left = true;
+            } else if ("start" in range) {
+              if (range.startinclusive) {
+                left = samplevalue >= range.start;
+              } else {
+                left = samplevalue > range.start;
+              }
+            }
+            if (range.stopunbounded) {
+              right = true;
+            } else if ("stop" in range) {
+              if (range.stopinclusive) {
+                right = samplevalue <= range.stop;
+              } else {
+                right = samplevalue < range.stop;
+              }
+            }
+            thistermmatch = left && right;
+          }
+          if (thistermmatch) break;
+        }
+      } else if (t.term.type == "condition") {
+        const key = getPrecomputedKey(t);
+        const anno = samplevalue && samplevalue[key];
+        if (anno) {
+          thistermmatch = Array.isArray(anno) ? t.values.find((d) => anno.includes(d.key)) : t.values.find((d) => d.key == anno);
+        }
+      } else if (t.term.type == "geneVariant") {
+        const svalues = samplevalue.values || [samplevalue];
+        for (const sv of svalues) {
+          thistermmatch = t.values.find(
+            (v) => v.dt == sv.dt && (!v.origin || sv.origin == v.origin) && (!v.mclasslst || v.mclasslst.includes(sv.class))
+          ) && true;
+          if (thistermmatch) break;
+        }
+      } else {
+        throw "unknown term type [sample_match_termvaluesetting() shared/utils/src/filter.ts]";
+      }
+      if (t.isnot) {
+        thistermmatch = !thistermmatch;
+      }
+      if (thistermmatch) numberofmatchedterms++;
+    }
+    if (filter.join == "or") {
+      if (numberofmatchedterms && filter.in) return true;
+      if (!numberofmatchedterms && !filter.in) return true;
+    }
+  }
+  if (!("in" in filter)) filter.in = true;
+  return filter.in == (numberofmatchedterms == lst.length);
+}
+function setDatasetAnnotations(item, ds = null) {
+  if (item.type == "tvslst") {
+    for (const subitem of item.lst) {
+      setDatasetAnnotations(subitem, ds);
+    }
+  } else {
+    if (ds && typeof ds.setAnnoByTermId == "function") {
+      ds.setAnnoByTermId(item.tvs.term.id);
+    }
+    if (item.tvs.term.type == "categorical") {
+      const tvsAny = item.tvs;
+      tvsAny.valueset = new Set(tvsAny.values.map((i) => i.key));
+    }
+  }
+}
+function getPrecomputedKey(q) {
+  const precomputedKey = q.bar_by_children && q.value_by_max_grade ? "childrenAtMaxGrade" : q.bar_by_children && q.value_by_most_recent ? "childrenAtMostRecent" : q.bar_by_children && q.value_by_computable_grade ? "children" : q.bar_by_grade && q.value_by_max_grade ? "maxGrade" : q.bar_by_grade && q.value_by_most_recent ? "mostRecentGrades" : q.bar_by_grade && q.value_by_computable_grade ? "computableGrades" : "";
+  if (!precomputedKey) throw `unknown condition term bar_by_* and/or value_by_*`;
+  return precomputedKey;
+}
+function getWrappedTvslst(lst = [], join = "", $id = null) {
+  const filter = {
+    type: "tvslst",
+    in: true,
+    join,
+    lst
+  };
+  if ($id !== null) filter.$id = $id;
+  return filter;
+}
+function getTvsDenominators(term) {
+  if (Array.isArray(term?.denominators) && term.denominators.length) return term.denominators;
+  return (term?.termlst || []).map((t) => t.id);
+}
+function validateTermCollectionTvs(term) {
+  const memberIds = validateTermCollectionTerm(term);
+  if (!term.numerators) return;
+  validateFractionMembers(term.numerators, getTvsDenominators(term), memberIds);
+}
+
+// ../shared/utils/dist/src/geneVariantFilter.js
+var statusClasses = /* @__PURE__ */ new Set(["WT", "Blank"]);
+function unsupported(what) {
+  return `tw.q.variantFilter does not support ${what}, which qualifies a sample rather than an individual variant. Use a groupset (q.type='custom-groupset') for a sample-level filter.`;
+}
+function validateVariantFilter(filter, term) {
+  if (!filter) return;
+  if (filter.type != "tvslst") throw `tw.q.variantFilter.type must be 'tvslst'`;
+  if (!Array.isArray(filter.lst) || !filter.lst.length) throw "tw.q.variantFilter.lst[] is empty";
+  if (filter.lst.length > 1 && filter.join != "and" && filter.join != "or")
+    throw `tw.q.variantFilter.join must be 'and' or 'or' when lst[] has more than one item`;
+  const dts = term?.childTerms?.length ? new Set(term.childTerms.map((t) => t.dt)) : null;
+  for (const item of filter.lst) {
+    if (item.type == "tvslst") {
+      validateVariantFilter(item, term);
+      continue;
+    }
+    if (item.type != "tvs") throw `unexpected tw.q.variantFilter item.type='${item.type}'`;
+    const tvs = item.tvs;
+    if (!tvs) throw "missing tvs of a tw.q.variantFilter item";
+    if (!Number.isInteger(tvs.term?.dt)) throw "tw.q.variantFilter tvs.term must be a dt term, with an integer .dt";
+    if (dts && !dts.has(tvs.term.dt))
+      throw `tw.q.variantFilter tvs.term.dt=${tvs.term.dt} is not a dt of term '${term.name}'`;
+    if (!Array.isArray(tvs.values) || !tvs.values.length) throw "tw.q.variantFilter tvs.values[] is empty";
+    for (const v of tvs.values) {
+      if (!v.key) throw "a tw.q.variantFilter tvs.values[] entry is missing .key";
+      if (statusClasses.has(v.key))
+        throw `tw.q.variantFilter cannot select the '${v.key}' class, which is a testing status and not a variant`;
+      if (v.partnerBreakpointRange) throw unsupported("partnerBreakpointRange");
+    }
+    if (tvs.genotype && tvs.genotype != "variant") throw unsupported(`genotype='${tvs.genotype}'`);
+    if (tvs.mcount && tvs.mcount != "any") throw unsupported(`mcount='${tvs.mcount}'`);
+    if (tvs.mafFilter) throw unsupported("mafFilter");
+    if (tvs.continuousCnv) throw unsupported("continuousCnv");
+    if (tvs.selfBreakpointRange) throw unsupported("selfBreakpointRange");
+  }
+}
+function getTvsOrigins(tvs) {
+  return tvs.origins?.length ? tvs.origins : void 0;
+}
+function getFilterScope(filter, scope = /* @__PURE__ */ new Set()) {
+  for (const item of filter.lst) {
+    if (item.type == "tvslst") {
+      getFilterScope(item, scope);
+      continue;
+    }
+    const origins = getTvsOrigins(item.tvs);
+    if (origins) for (const origin of origins) scope.add(`${item.tvs.term.dt}:${origin}`);
+    else scope.add(`${item.tvs.term.dt}:*`);
+  }
+  return scope;
+}
+function isInScope(v, scope) {
+  return scope.has(`${v.dt}:*`) || scope.has(`${v.dt}:${v.origin || ""}`);
+}
+function matchTvs(v, tvs) {
+  let match = false;
+  const origins = getTvsOrigins(tvs);
+  if (v.dt == tvs.term.dt && (!origins || origins.includes(v.origin))) {
+    match = tvs.values.some((e) => e.key == v.class && (!e.mname || e.mname == v.mname && matchesGvQueryEntry(e, v)));
+  }
+  return tvs.isnot ? !match : match;
+}
+function matchFilter(v, filter) {
+  const lst = filter.type == "tvslst" ? filter.lst : [filter];
+  let numMatched = 0;
+  for (const item of lst) {
+    const matched = item.type == "tvslst" ? matchFilter(v, item) : matchTvs(v, item.tvs);
+    if (matched) numMatched++;
+    if (filter.join == "or" && numMatched) break;
+  }
+  const pass = filter.join == "or" ? numMatched > 0 : numMatched == lst.length;
+  return filter.in === false ? !pass : pass;
+}
+function filterVariantValues(values, filter) {
+  if (!filter || !values) return values;
+  const scope = getFilterScope(filter);
+  const kept = [];
+  const annotated = /* @__PURE__ */ new Set();
+  const dropped = /* @__PURE__ */ new Map();
+  for (const v of values) {
+    if (!isInScope(v, scope)) continue;
+    const key = `${v.dt}:${v.origin || ""}`;
+    if (statusClasses.has(v.class) || matchFilter(v, filter)) {
+      kept.push(v);
+      annotated.add(key);
+    } else if (!dropped.has(key)) {
+      dropped.set(key, v);
+    }
+  }
+  for (const [key, v] of dropped) {
+    if (annotated.has(key)) continue;
+    const wt = { dt: v.dt, class: "WT", label: mclass.WT.label };
+    if (v.gene) wt.gene = v.gene;
+    if (v.origin) wt.origin = v.origin;
+    kept.push(wt);
+  }
+  return kept;
+}
+function variantFilterLabel(filter, mclassOverride, maxItems = 3) {
+  if (!filter) return "";
+  const entries = [];
+  collect(filter, false);
+  function collect(f, negated) {
+    const flipped = f.in === false ? !negated : negated;
+    for (const item of f.lst) {
+      if (item.type == "tvslst") collect(item, flipped);
+      else if (flipped === !!item.tvs.isnot) entries.push(...item.tvs.values);
+    }
+  }
+  if (!entries.length) return "";
+  const classes = mclass;
+  const names = [
+    ...new Set(entries.map((e) => e.mname || mclassOverride?.[e.key]?.label || classes[e.key]?.label || e.key))
+  ];
+  return names.length > maxItems ? `${names.slice(0, maxItems).join("/")}\u2026` : names.join("/");
+}
+
+export {
+  isFractionTw,
+  getFractionTvsTerm,
+  validateTermCollectionFraction,
+  getFilteredSamples,
+  sample_match_termvaluesetting,
+  getWrappedTvslst,
+  getTvsDenominators,
+  validateTermCollectionTvs,
+  validateVariantFilter,
+  filterVariantValues,
+  variantFilterLabel
+};
+//# sourceMappingURL=chunk-2IAELUCN.js.map

package/dist/chunk-2W6U53AG.js

@@ -0,0 +1,195 @@
+import {
+  sample_match_termvaluesetting
+} from "./chunk-DOC3HBOV.js";
+import {
+  isDictionaryType
+} from "./chunk-CFYWQJ7F.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" && config.settings.matrix.mapChildren2Root) opts.mapChildren2Root = true;
+  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-2W6U53AG.js.map