@sjcrh/proteinpaint-client 2.205.0 → 2.206.0

package/dist/chunk-5DBW3WLK.js

@@ -0,0 +1,129 @@
+import {
+  keyupEnter
+} from "./chunk-Q5SK3U2T.js";
+
+// src/block.mds.svcnv.share.js
+function rnabamtk_initparam(c) {
+  if (!c.dna_mintotalreads) c.dna_mintotalreads = 8;
+  if (!c.rna_mintotalreads) c.rna_mintotalreads = 8;
+  if (!c.hetsnp_minbaf) c.hetsnp_minbaf = 0.3;
+  if (!c.hetsnp_maxbaf) c.hetsnp_maxbaf = 0.7;
+  if (c.rnapileup_q == void 0) c.rnapileup_q = 0;
+  if (!c.rnapileup_Q) c.rnapileup_Q = 13;
+  if (!c.binompvaluecutoff) c.binompvaluecutoff = 0.05;
+  if (!c.clientcolor_snpinuse) c.clientcolor_snpinuse = "blue";
+  if (!c.clientcolor_markernotinuse) c.clientcolor_markernotinuse = "#bbb";
+}
+function configPanel_rnabam(tk, block, loadTk) {
+  const c = tk.checkrnabam;
+  if (!c) return;
+  tk.tkconfigtip.d.append("hr");
+  const d = tk.tkconfigtip.d.append("div").style("margin", "15px 0px");
+  d.append("div").style("opacity", 0.5).style("font-size", ".9em").text("Finding heterozygous SNPs in DNA");
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("DNA minimum total read count ");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.dna_mintotalreads).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.dna_mintotalreads == v) {
+        return;
+      }
+      c.dna_mintotalreads = v;
+      loadTk(tk, block);
+    });
+    row.append("div").style("opacity", ".5").style("font-size", ".8em").text("If a SNP's total coverage is below cutoff, it will be skipped.");
+  }
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("Heterozygous SNP BAF range&nbsp;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.hetsnp_minbaf).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.hetsnp_minbaf == v) {
+        return;
+      }
+      c.hetsnp_minbaf = v;
+      loadTk(tk, block);
+    });
+    row.append("span").style("opacity", ".5").style("font-size", ".8em").html("&nbsp;&leq; BAF &leq;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.hetsnp_maxbaf).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.hetsnp_maxbaf == v) {
+        return;
+      }
+      c.hetsnp_maxbaf = v;
+      loadTk(tk, block);
+    });
+    row.append("div").style("opacity", ".5").style("font-size", ".8em").text("If a SNP's BAF (B-allele fraction) is within this range, it is heterozygous.");
+  }
+  d.append("div").style("margin-top", "20px").style("opacity", 0.5).style("font-size", ".9em").text("Counting alleles in RNA-seq BAM file");
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("Skip alignments with mapQ smaller than&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.rnapileup_q).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v < 0) return;
+      if (c.rnapileup_q == v) {
+        return;
+      }
+      c.rnapileup_q = v;
+      loadTk(tk, block);
+    });
+  }
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("Skip bases with baseQ/BAQ smaller than&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.rnapileup_Q).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.rnapileup_Q == v) {
+        return;
+      }
+      c.rnapileup_Q = v;
+      loadTk(tk, block);
+    });
+  }
+  d.append("div").style("margin-top", "20px").style("opacity", 0.5).style("font-size", ".9em").text("Binomial test on whether a heterozygous SNP shows allelic bias in RNA");
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("P-value cutoff&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.binompvaluecutoff).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0 || v >= 1) return;
+      if (c.binompvaluecutoff == v) {
+        return;
+      }
+      c.binompvaluecutoff = v;
+      loadTk(tk, block);
+    });
+  }
+  {
+    const row = d.append("div").style("margin-top", "5px");
+    row.append("span").html("RNA minimum total read count&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", c.rna_mintotalreads).on("keyup", (event) => {
+      if (!keyupEnter(event)) return;
+      let v = Number.parseInt(event.target.value);
+      if (!v || v <= 0) return;
+      if (c.rna_mintotalreads == v) {
+        return;
+      }
+      c.rna_mintotalreads = v;
+      loadTk(tk, block);
+    });
+    row.append("div").style("opacity", ".5").style("font-size", ".8em").text("If a SNP's total read count from RNA is below cutoff, it won't do binomial test.");
+  }
+}
+
+export {
+  rnabamtk_initparam,
+  configPanel_rnabam
+};
+//# sourceMappingURL=chunk-5DBW3WLK.js.map

package/dist/chunk-5ILEFNXJ.js

@@ -0,0 +1,402 @@
+import {
+  CATEGORICAL,
+  COHORT,
+  CONDITION,
+  DATE,
+  DNA_METHYLATION,
+  FLOAT,
+  GENE_EXPRESSION,
+  GENE_VARIANT,
+  INTEGER,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  METABOLITE_INTENSITY,
+  MULTIVALUE,
+  PROTEOME_ABUNDANCE,
+  PSEUDOBULK,
+  SAMPLELST,
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION,
+  SNP,
+  SNP_LIST,
+  SNP_LOCUS,
+  SSGSEA,
+  SURVIVAL,
+  TERM_COLLECTION,
+  TermTypeGroups,
+  dtTerms,
+  dtdnamethylation,
+  dtgeneexpression,
+  dtmetaboliteintensity,
+  dtproteomeabundance,
+  dtssgsea
+} from "./chunk-IZUYLFOX.js";
+
+// ../shared/utils/dist/src/terms.js
+var ROOT_SAMPLE_TYPE = 1;
+var DEFAULT_SAMPLE_TYPE = 2;
+var NumericModes = {
+  continuous: "continuous",
+  discrete: "discrete"
+};
+var dtTermTypes = new Set(dtTerms.map((t) => t.type));
+var TermTypes2Dt = {
+  [GENE_EXPRESSION]: dtgeneexpression,
+  [SSGSEA]: dtssgsea,
+  [DNA_METHYLATION]: dtdnamethylation,
+  [METABOLITE_INTENSITY]: dtmetaboliteintensity,
+  [PROTEOME_ABUNDANCE]: dtproteomeabundance
+};
+var typeGroup = {
+  [CATEGORICAL]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [CONDITION]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [FLOAT]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [INTEGER]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [SAMPLELST]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [SURVIVAL]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [DATE]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [MULTIVALUE]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [GENE_VARIANT]: TermTypeGroups.MUTATION_CNV_FUSION,
+  [SNP]: TermTypeGroups.SNP,
+  [SNP_LIST]: TermTypeGroups.SNP_LIST,
+  [SNP_LOCUS]: TermTypeGroups.SNP_LOCUS,
+  [GENE_EXPRESSION]: TermTypeGroups.GENE_EXPRESSION,
+  [ISOFORM_EXPRESSION]: TermTypeGroups.ISOFORM_EXPRESSION,
+  [JUNCTION]: TermTypeGroups.SPLICE_JUNCTION,
+  [SSGSEA]: TermTypeGroups.SSGSEA,
+  [DNA_METHYLATION]: TermTypeGroups.DNA_METHYLATION,
+  [METABOLITE_INTENSITY]: TermTypeGroups.METABOLITE_INTENSITY,
+  [PROTEOME_ABUNDANCE]: TermTypeGroups.PROTEOME_ABUNDANCE,
+  [PSEUDOBULK]: TermTypeGroups.PSEUDOBULK,
+  [TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION,
+  [SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE,
+  [SINGLECELL_GENE_EXPRESSION]: TermTypeGroups.SINGLECELL_GENE_EXPRESSION,
+  [COHORT]: TermTypeGroups.COHORT
+};
+var nonDictTypes = /* @__PURE__ */ new Set([
+  SNP,
+  SNP_LIST,
+  SNP_LOCUS,
+  GENE_EXPRESSION,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  SSGSEA,
+  DNA_METHYLATION,
+  GENE_VARIANT,
+  METABOLITE_INTENSITY,
+  PROTEOME_ABUNDANCE,
+  PSEUDOBULK,
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION,
+  COHORT
+]);
+for (const dtTermType of dtTermTypes) {
+  nonDictTypes.add(dtTermType);
+}
+var numericTypes = /* @__PURE__ */ new Set([
+  INTEGER,
+  FLOAT,
+  GENE_EXPRESSION,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  SSGSEA,
+  DNA_METHYLATION,
+  METABOLITE_INTENSITY,
+  PROTEOME_ABUNDANCE,
+  SINGLECELL_GENE_EXPRESSION,
+  DATE,
+  PSEUDOBULK
+]);
+var dictionaryNumericTypes = /* @__PURE__ */ new Set([INTEGER, FLOAT, DATE]);
+var categoricalTypes = /* @__PURE__ */ new Set([CATEGORICAL, SNP]);
+var singleCellTerms = /* @__PURE__ */ new Set([
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION
+  /*PSEUDOBULK*/
+]);
+function isSingleCellTerm(term) {
+  if (!term) return false;
+  return singleCellTerms.has(term.type);
+}
+function isNumericTerm(term) {
+  if (!term) return false;
+  return numericTypes.has(term.type);
+}
+function isNumericTw(tw) {
+  if (!tw?.term) return false;
+  return isNumericTerm(tw.term) || tw.term.type === TERM_COLLECTION && tw.term.memberType === "numeric" && tw.type === "TermCollectionTWFraction";
+}
+function isCategoricalTerm(term) {
+  if (!term) return false;
+  return categoricalTypes.has(term.type);
+}
+function isDictionaryType(type) {
+  return !isNonDictionaryType(type);
+}
+function isNonDictionaryType(type) {
+  if (!type) throw new Error("Type is not defined");
+  return nonDictTypes.has(type);
+}
+function isNumTermCollection(term) {
+  if (!term || !term.type) throw new Error("Term or term type is not defined");
+  return term.type === TERM_COLLECTION;
+}
+function equals(t1, t2) {
+  if (!t1) throw new Error("First term is not defined ");
+  if (!t2) throw new Error("Second term is not defined ");
+  if (t1.type !== t2.type) return false;
+  if (isDictionaryType(t1.type) && isDictionaryType(t2.type) && t1.type != SAMPLELST) return t1.id === t2.id;
+  switch (t1.type) {
+    case GENE_EXPRESSION:
+      return t1.gene == t2.gene;
+    case ISOFORM_EXPRESSION:
+      return t1.isoform == t2.isoform;
+    case JUNCTION:
+      return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop && t1.strand == t2.strand;
+    case SSGSEA:
+      return t1.id == t2.id;
+    case DNA_METHYLATION:
+      return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop;
+    case METABOLITE_INTENSITY:
+    case PROTEOME_ABUNDANCE:
+      return t1.name == t2.name;
+    case GENE_VARIANT:
+      return t1.gene == t2.gene || t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop;
+    // TO DO: Add more cases
+    // case SNP_LIST:
+    // case SNP_LOCUS:
+    // case SAMPLELST:
+    default:
+      return false;
+  }
+}
+function trimGvTermCopy(term, q) {
+  if (term?.type != GENE_VARIANT) return term;
+  delete term.childTerms;
+  if (q?.customset) clearGroupsetParentTerms(q.customset);
+  const lst = term.groupsetting?.lst;
+  if (!lst?.length) return term;
+  if (q?.type == "predefined-groupset") {
+    const idx = q.predefined_groupset_idx;
+    term.groupsetting.lst = lst.map((groupset, i) => i === idx ? groupset : null);
+    clearDtTermMnames(term.groupsetting.lst[idx]);
+    clearGroupsetParentTerms(term.groupsetting.lst[idx]);
+  } else {
+    delete term.groupsetting.lst;
+  }
+  return term;
+}
+function forEachGvTw(obj, callback) {
+  if (!obj || typeof obj != "object") return;
+  if (obj.q && obj.term?.type == GENE_VARIANT) callback(obj);
+  for (const value of Object.values(obj)) forEachGvTw(value, callback);
+}
+function trimGvTermsForSave(obj) {
+  forEachGvTw(obj, (tw) => {
+    delete tw.term.childTerms;
+    delete tw.term.groupsetting;
+    if (tw.q.customset) clearGroupsetParentTerms(tw.q.customset);
+  });
+  return obj;
+}
+function getGvGeneKey(term) {
+  const genes = term?.genes?.length ? term.genes : term ? [term] : [];
+  const keys = genes.map((gene) => {
+    if (getGvGeneKind(gene) == "coord") {
+      const region = getGvQueryRegion(gene);
+      return region ? `${region.chr}:${region.start + 1}-${region.stop}` : void 0;
+    }
+    return gene.gene || gene.name;
+  }).filter((key) => typeof key == "string" && key);
+  if (!keys.length || keys.length != genes.length) return "";
+  return keys.sort().join(",");
+}
+var gvQCacheKeyPrefix = "gv:";
+function getGvQCacheKey(term) {
+  const key = getGvGeneKey(term);
+  return key ? gvQCacheKeyPrefix + key : "";
+}
+function getGvGeneKind(gene) {
+  if (gene?.kind) return gene.kind;
+  if (gene?.gene || gene?.name && !gene.chr) return "gene";
+  if (gene?.chr) return "coord";
+  return void 0;
+}
+function trimGvQForCache(q) {
+  const copy = structuredClone(q);
+  delete copy.isAtomic;
+  delete copy.hiddenValues;
+  delete copy.dtLst;
+  if (copy.customset) {
+    clearDtTermMnames(copy.customset);
+    clearGroupsetParentTerms(copy.customset);
+  }
+  return copy;
+}
+function getGvQueryRegion(gene) {
+  if (!gene?.chr || !Number.isInteger(gene.start) || !Number.isInteger(gene.stop)) return;
+  return { chr: gene.chr, start: gene.start, stop: gene.stop };
+}
+function restoreGvQueryEntry(v, queries) {
+  if (!queries || v?.$q === void 0) return false;
+  Object.assign(v, queries[v.$q]);
+  delete v.$q;
+  return true;
+}
+function matchesGvQueryEntry(entry, v) {
+  if (entry.gene) return entry.gene == v.gene;
+  const r = entry.region;
+  if (r) return !!v.region && r.chr == v.region.chr && r.start == v.region.start && r.stop == v.region.stop;
+  return true;
+}
+function setGroupsetParentTerms(groupset, term) {
+  if (term?.type != GENE_VARIANT) throw "parent of a groupset tvs must be a geneVariant term";
+  const parentTerm = structuredClone(term);
+  delete parentTerm.childTerms;
+  delete parentTerm.groupsetting;
+  walkTvs(groupset, (tvs) => {
+    if (!dtTermTypes.has(tvs.term?.type)) throw `groupset tvs term is not a dt term`;
+    tvs.term.parentTerm = parentTerm;
+  });
+  return groupset;
+}
+function clearGroupsetParentTerms(groupset) {
+  walkTvs(groupset, (tvs) => {
+    if (tvs.term) delete tvs.term.parentTerm;
+  });
+  return groupset;
+}
+function walkTvs(obj, fn) {
+  if (!obj || typeof obj != "object") return;
+  if (obj.type == "tvs" && obj.tvs) {
+    fn(obj.tvs);
+    return;
+  }
+  for (const k in obj) walkTvs(obj[k], fn);
+}
+function getDtsFromGroups(groups) {
+  const dts = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    for (const dt of getDtsFromFilter(group.filter)) dts.add(dt);
+  }
+  return [...dts];
+}
+function getDtsFromFilter(filter) {
+  const dts = /* @__PURE__ */ new Set();
+  for (const item of filter.lst) {
+    if (item.type == "tvslst") {
+      for (const dt of getDtsFromFilter(item)) dts.add(dt);
+    } else {
+      dts.add(item.tvs.term.dt);
+    }
+  }
+  return dts;
+}
+function clearDtTermMnames(obj) {
+  walkTvs(obj, (tvs) => {
+    if (tvs.term) delete tvs.term.mnames;
+  });
+  return obj;
+}
+var typeMap = {
+  categorical: "Categorical",
+  condition: "Condition",
+  float: "Numerical",
+  integer: "Numerical",
+  date: "Date",
+  geneExpression: "Gene Expression",
+  isoformExpression: "Isoform Expression",
+  [JUNCTION]: "Splice junction",
+  ssGSEA: "Geneset Expression",
+  dnaMethylation: "DNA Methylation",
+  geneVariant: "Gene Variant",
+  metaboliteIntensity: "Metabolite Intensity",
+  proteomeAbundance: "Proteome Abundance",
+  proteomeDAP: "Proteome DAP",
+  multivalue: "Multi Value",
+  singleCellGeneExpression: "Single Cell, Gene Expression",
+  singleCellCellType: "Single Cell, Cell Type",
+  snplocus: "SNP Locus",
+  snp: "SNP",
+  snplst: "SNP List",
+  termCollection: "Term Collection"
+};
+function termItemType(t) {
+  switch (t.type) {
+    case JUNCTION:
+      return "Splice junction";
+    case GENE_EXPRESSION:
+    case SINGLECELL_GENE_EXPRESSION:
+      return "Gene";
+    case ISOFORM_EXPRESSION:
+      return "Isoform";
+    case SSGSEA:
+      return "Gene set";
+    case METABOLITE_INTENSITY:
+      return "Metabolite";
+    // keep adding here
+    default:
+      return "Variable";
+  }
+}
+function termType2label(type) {
+  const s = typeMap[type];
+  if (s) return s;
+  throw new Error("termType2label(): unknown value");
+}
+function getDateFromNumber(value) {
+  const year = Math.floor(value);
+  const january1st = new Date(year, 0, 1);
+  const totalDays = getDaysInYear(year);
+  const time = Math.round((value - year) * totalDays) * oneDayTime;
+  const date = new Date(january1st.getTime() + time);
+  return date;
+}
+var oneDayTime = 24 * 60 * 60 * 1e3;
+function getDateStrFromNumber(value) {
+  const date = getDateFromNumber(value);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long"
+  });
+}
+function getDaysInYear(year) {
+  const isLeap = new Date(year, 1, 29).getMonth() === 1;
+  const days = isLeap ? 366 : 365;
+  return days;
+}
+
+export {
+  ROOT_SAMPLE_TYPE,
+  DEFAULT_SAMPLE_TYPE,
+  NumericModes,
+  dtTermTypes,
+  TermTypes2Dt,
+  typeGroup,
+  numericTypes,
+  dictionaryNumericTypes,
+  isSingleCellTerm,
+  isNumericTerm,
+  isNumericTw,
+  isCategoricalTerm,
+  isDictionaryType,
+  isNonDictionaryType,
+  isNumTermCollection,
+  equals,
+  trimGvTermCopy,
+  forEachGvTw,
+  trimGvTermsForSave,
+  gvQCacheKeyPrefix,
+  getGvQCacheKey,
+  trimGvQForCache,
+  restoreGvQueryEntry,
+  matchesGvQueryEntry,
+  setGroupsetParentTerms,
+  getDtsFromGroups,
+  clearDtTermMnames,
+  termItemType,
+  termType2label,
+  getDateFromNumber,
+  getDateStrFromNumber
+};
+//# sourceMappingURL=chunk-5ILEFNXJ.js.map

package/dist/chunk-5UO7MKCO.js

@@ -0,0 +1,59 @@
+import {
+  plotColor
+} from "./chunk-IZUYLFOX.js";
+
+// plots/scatter/settings/defaults.ts
+function getDefaultScatterSettings(opts = {}) {
+  const overrides = opts?.overrides || {};
+  const defaults = {
+    size: 0.8,
+    minShapeSize: 0.5,
+    maxShapeSize: 4,
+    scaleDotOrder: "Ascending",
+    refSize: 0.8,
+    svgw: 600,
+    svgh: 600,
+    svgd: 600,
+    axisTitleFontSize: 16,
+    showAxes: true,
+    showRef: true,
+    opacity: 0.6,
+    defaultColor: plotColor,
+    regression: "None",
+    fov: 50,
+    threeSize: 5e-3,
+    threeFOV: 70,
+    //ColorScale settings
+    colorScaleMode: "auto",
+    colorScalePercentile: 95,
+    colorScaleMinFixed: null,
+    colorScaleMaxFixed: null,
+    //3D Plot settings
+    showContour: false,
+    colorContours: false,
+    contourBandwidth: 30,
+    contourThresholds: 10,
+    duration: 500,
+    useGlobalMinMax: true,
+    saveZoomTransform: false,
+    // Axis scale settings
+    minXScale: null,
+    maxXScale: null,
+    minYScale: null,
+    maxYScale: null,
+    itemLabel: opts?.singleCellPlot ? "Cell" : "Sample",
+    maxTooltipRows: 5
+  };
+  return Object.assign(defaults, overrides);
+}
+var maxSvgSamplesCutoff = 2e4;
+var noExpColor = "#F5F5F5";
+var expColor = "#ff000d";
+
+export {
+  getDefaultScatterSettings,
+  maxSvgSamplesCutoff,
+  noExpColor,
+  expColor
+};
+//# sourceMappingURL=chunk-5UO7MKCO.js.map