@sjcrh/proteinpaint-shared 2.177.1-0 → 2.178.1-0

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@sjcrh/proteinpaint-shared",
-  "version": "2.177.1-0",
+  "version": "2.178.1-0",
   "description": "ProteinPaint code that is shared between server and client-side workspaces",
   "type": "module",
   "main": "src/index.js",
+  "imports": {
+    "#types": "@sjcrh/proteinpaint-types",
+    "#types/*": "@sjcrh/proteinpaint-types/*"
+  },
   "exports": {
     ".": "./src/index.js",
     "./*.ts": "./src/*.ts_SHOULD_BE_js",

package/src/common.js

@@ -22,10 +22,12 @@ export const TermTypeGroups = {
 	GENE_EXPRESSION: 'Gene Expression',
 	GSEA: 'GSEA',
 	METABOLITE_INTENSITY: 'Metabolite Intensity',
+	WHOLE_PROTEOME_ABUNDANCE: 'Whole Proteome Abundance',
 	MUTATION_CNV_FUSION: 'Mutation/CNV/Fusion',
 	MUTATION_SIGNATURE: 'Mutation Signature',
 	PROTEIN_EXPRESSION: 'Protein Expression',
 	SINGLECELL_CELLTYPE: 'Single-cell Cell Type',
+	SINGLECELL_GENE_EXPRESSION: 'Single-cell Gene Expression',
 	SNP: 'SNP Genotype',
 	SNP_LIST: 'SNP List',
 	SNP_LOCUS: 'SNP Locus',
@@ -66,6 +68,7 @@ export const dtloh = 10
 export const dtmetaboliteintensity = 11
 export const dtssgsea = 12
 export const dtdnamethylation = 13
+export const dtwholeproteomeabundance = 14
 // add new dt value here. !!!DO NOT change value of existing dt!!!
 
 export const dt2label = {
@@ -79,7 +82,8 @@ export const dt2label = {
 	[dtcloss]: 'C-loss',
 	[dtloh]: 'LOH',
 	[dtgeneexpression]: 'Gene Expression',
-	[dtmetaboliteintensity]: 'Metabolite Intensity'
+	[dtmetaboliteintensity]: 'Metabolite Intensity',
+	[dtwholeproteomeabundance]: 'Whole Proteome Abundance'
 }
 
 // Maps dt types to UI labels and lesion types for GRIN2

package/src/fetch-helpers.js

@@ -223,22 +223,27 @@ export async function memFetch(url, init, opts = {}) {
 						dataCache.set(dataKey, { response, exp: Date.now() + cacheLifetime })
 						return response
 				  })
-				: fetch(url, init).then(async r => {
-						const response = await processResponse(r)
-						if (!r.ok) {
-							console.trace(response)
-							throw (
-								'memFetch error ' +
-								r.status +
-								': ' +
-								(typeof response == 'object' ? response.message || response.error : response)
-							)
-						}
-						// replace the cached promise result with the actual data,
-						// since persisting a cached promise for a long time is likely not best practice
-						dataCache.set(dataKey, { response: deepFreeze(response), exp: Date.now() + cacheLifetime })
-						return response
-				  })
+				: fetch(url, init)
+						.then(async r => {
+							const response = await processResponse(r)
+							if (!r.ok) {
+								console.trace(response)
+								throw (
+									'memFetch error ' +
+									r.status +
+									': ' +
+									(typeof response == 'object' ? response.message || response.error : response)
+								)
+							}
+							// replace the cached promise result with the actual data,
+							// since persisting a cached promise for a long time is likely not best practice
+							dataCache.set(dataKey, { response: deepFreeze(response), exp: Date.now() + cacheLifetime })
+							return response
+						})
+						.catch(e => {
+							if (dataCache.get(dataKey)) dataCache.delete(dataKey)
+							throw e
+						})
 
 			dataCache.set(dataKey, { response: result, exp: Date.now() + cacheLifetime })
 			manageCacheSize(now)
@@ -246,7 +251,7 @@ export async function memFetch(url, init, opts = {}) {
 		} catch (e) {
 			// delete this cache only if it is a promise;
 			// do not delete a valid resolved data cache
-			if (dataCache.get(dataKey) instanceof Promise) delete dataCache.delete(dataKey)
+			if (dataCache.get(dataKey) instanceof Promise) dataCache.delete(dataKey)
 			throw e
 		}
 	}

package/src/filter.js

@@ -1,255 +1,193 @@
-/*
-	sampleAnno[anno{}] array of sample annotations
-		anno.sample 
-			- string or number sample name
-		
-		anno.s || anno.data
-			- the annotation object {[key1]: value1, ...}
-		
-	filter: nested filter structure as used in the termdbapp, see docs
-*/
-export function getFilteredSamples(sampleAnno, filter) {
-	setDatasetAnnotations(filter)
-
-	const samples = 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 // return as a Set, or maybe as an array later
+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;
 }
-
-/*
-given a value from a sample's anno of a term, return true if a value matches the filter
-*/
-export function sample_match_termvaluesetting(row, filter, _term = null, sample = null) {
-	const lst = filter.type == 'tvslst' ? filter.lst : [filter]
-	let numberofmatchedterms = 0
-
-	/* for AND, require all terms to match */
-	for (const item of lst) {
-		if (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)) {
-					// for an filter from "this.config.legendValueFilter", if the filter is not for the tw
-					// (not the same type and name), ignore the filter.
-					numberofmatchedterms++
-					continue
-				}
-			}
-
-			let samplevalue
-			if (_term && !t.term) {
-				if (t.term$type && t.term$type !== _term.type) {
-					//when the filter is not for the term being tested, ignore the filter
-					numberofmatchedterms++
-					continue
-				}
-				t.term = _term
-				samplevalue = typeof row === 'object' && t.term.id in row ? row[t.term.id] : row //'tumorWES'
-			} 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 === undefined) continue // this sample has no anno for this term, do not count
-				thistermmatch = t.valueset.has(samplevalue)
-			} else if (t.term.type == 'integer' || t.term.type == 'float') {
-				if (samplevalue === undefined) continue // this sample has no anno for this term, do not count
-				for (const range of t.ranges) {
-					if ('value' in range) {
-						thistermmatch = samplevalue === range.value // || ""+samplevalue == range.value || samplevalue == ""+range.value //; if (thistermmatch) console.log(i++)
-						if (thistermmatch) break
-					} else if (samplevalue == range.name) {
-						thistermmatch = true
-						break
-					} else {
-						// actual range
-						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') {
-				/*
-				samplevalue.values here can be an array or only one of the entries 
-				[
-					{ dt: 1, class: 'WT', _SAMPLEID_: 21, origin: 'germline' },
-					{ dt: 1, class: 'WT', _SAMPLEID_: 21, origin: 'somatic' },
-					{ dt: 2, class: 'Blank', _SAMPLEID_: 21 },
-					{ dt: 4, class: 'WT', _SAMPLEID_: 21 }
-				]
-				*/
-				/* tvs.values is an array that stores classes (for each available dt) that have/haven't been crossed out by the user at this round of edit-and-apply, e.g.
-          [
-            {dt: 1, mclassLst: ['WT'], mclassExcludeLst: ['Blank'], origin: 'germline'}
-            {dt: 1, mclassLst: ['Blank', 'WT', 'M'], mclassExcludeLst:[], origin:'somatic'},
-            {dt: 2, mclassLst: ['Blank', 'WT'], mclassExcludeLst:[]}
-            {dt: 4, mclassLst: ['WT', 'CNV_loss'], mclassExcludeLst:[]}
-          ]
-        */
-				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 //; console.log(114, t.values[0].dt, samplevalue.dt, thistermmatch)
-				}
-			} else {
-				throw 'unknown term type [sample_match_termvaluesetting() shared/utils/src/filter.js]'
-			}
-
-			if (t.isnot) {
-				thistermmatch = !thistermmatch
-			}
-			if (thistermmatch) numberofmatchedterms++
-		}
-
-		// if one tvslst is matched with an "or" (Set UNION), then sample is okay
-		if (filter.join == 'or') {
-			if (numberofmatchedterms && filter.in) return true
-			if (!numberofmatchedterms && !filter.in) return true
-		}
-	}
-	// for join="and" (Set intersection)
-	if (!('in' in filter)) filter.in = true
-	return filter.in == (numberofmatchedterms == lst.length)
-	// if (filter.in && numberofmatchedterms == lst.length) return true
-	// if (!filter.in && numberofmatchedterms != lst.length) return true
+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);
 }
-
-export 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') {
-			item.tvs.valueset = new Set(item.tvs.values.map(i => i.key))
-		}
-	}
+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
+  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;
 }
-
-/* join a list of filters into the first filter with "and", return joined filter
-to be used by caller app to join hidden filters into a visible filter
-
-lst:[]
-  a list of filters
-  the function returns a (modified) copy of the first filter, and will not modify it
-  rest of the array will be joined to the first one under "and"
-*/
-export function filterJoin(lst) {
-	if (!lst || lst.length == 0) return
-	let f = JSON.parse(JSON.stringify(lst[0]))
-	if (lst.length == 1) return f
-	// more than 1 item, will join
-	if (f.lst.length < 2) {
-		if (f.join !== '') throw 'filter.join must be an empty string "" when filter.lst.length < 2'
-		f.join = 'and'
-	} else if (f.join == 'or') {
-		// f is "or", wrap it with another root layer of "and"
-		f = {
-			type: 'tvslst',
-			join: 'and',
-			in: true,
-			lst: [f]
-		}
-	} else if (f.join != 'and') {
-		throw 'filter.join must be either "and" or "or" when .lst length > 1'
-	}
-	// now, f.join should be "and"
-	// if the argument lst[0].join == "and",
-	// then the f.in boolean value is reused
-	for (let i = 1; i < lst.length; i++) {
-		const f2 = JSON.parse(JSON.stringify(lst[i]))
-		if (f2.join == 'or') f.lst.push(f2)
-		else f.lst.push(...f2.lst)
-	}
-	// if f ends up single-tvs item (from joining single tvs to empty filter), need to set join to '' per filter spec
-	if (f.lst.length == 1 && f.lst[0].type == 'tvs') {
-		f.join = ''
-	}
-	return f
+function filterJoin(lst) {
+  if (!lst || lst.length == 0) return;
+  let f = JSON.parse(JSON.stringify(lst[0]));
+  if (lst.length == 1) return f;
+  if (f.lst.length < 2) {
+    if (f.join !== "") throw 'filter.join must be an empty string "" when filter.lst.length < 2';
+    f.join = "and";
+  } else if (f.join == "or") {
+    f = {
+      type: "tvslst",
+      join: "and",
+      in: true,
+      lst: [f]
+    };
+  } else if (f.join != "and") {
+    throw 'filter.join must be either "and" or "or" when .lst length > 1';
+  }
+  for (let i = 1; i < lst.length; i++) {
+    const f2 = JSON.parse(JSON.stringify(lst[i]));
+    if (f2.join == "or") f.lst.push(f2);
+    else f.lst.push(...f2.lst);
+  }
+  if (f.lst.length == 1 && f.lst[0].type == "tvs") {
+    f.join = "";
+  }
+  return f;
 }
-
-export function getWrappedTvslst(lst = [], join = '', $id = null) {
-	const filter = {
-		type: 'tvslst',
-		in: true,
-		join,
-		lst
-	}
-	if ($id !== null && filter.$id !== undefined) filter.$id = $id
-	return filter
+function getWrappedTvslst(lst = [], join = "", $id = null) {
+  const filter = {
+    type: "tvslst",
+    in: true,
+    join,
+    lst
+  };
+  if ($id !== null) filter.$id = $id;
+  return filter;
 }
+function validateTermCollectionTvs(lst1, lst2) {
+  if (!Array.isArray(lst1)) throw new Error("numerator not array");
+  if (!Array.isArray(lst2)) throw new Error("denominator not array");
+  if (lst1.length == 0) throw new Error("numerator empty");
+  if (lst2.length == 0) throw new Error("denominator empty");
+  if (lst1.length > lst2.length) throw new Error("numerator longer than denominator");
+  for (const s of lst1) {
+    if (typeof s != "string") throw new Error("one of numerator not string");
+    if (!s) throw new Error("empty string in numerator");
+    if (!lst2.includes(s)) throw new Error("one of numerator not in denominator");
+  }
+}
+export {
+  filterJoin,
+  getFilteredSamples,
+  getWrappedTvslst,
+  sample_match_termvaluesetting,
+  setDatasetAnnotations,
+  validateTermCollectionTvs
+};

package/src/termdb.usecase.js

@@ -19,6 +19,7 @@ export const graphableTypes = new Set([
 	TermTypes.SSGSEA,
 	TermTypes.DNA_METHYLATION,
 	TermTypes.METABOLITE_INTENSITY,
+	TermTypes.WHOLE_PROTEOME_ABUNDANCE,
 	TermTypes.SINGLECELL_GENE_EXPRESSION,
 	TermTypes.SINGLECELL_CELLTYPE,
 	TermTypes.SNP,
@@ -67,8 +68,8 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 	const usecase = _usecase || {}
 
 	// may apply dataset specific override filter for a use case
-	if (typeof ds?.usecase?.[use.target] == 'function') {
-		return ds.usecase[use.target](term, use)
+	if (typeof ds?.usecase?.[usecase.target] == 'function') {
+		return ds.usecase[usecase.target](term, usecase)
 	}
 
 	// if (term.isprivate && !user.roleCanUse(term)) return false
@@ -76,7 +77,6 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 	const uses = new Set()
 	// note: expects term.child_types to be null if term.isleaf == true
 	const child_types = term.child_types || []
-
 	// default handling
 	switch (usecase.target) {
 		case 'barchart':
@@ -92,6 +92,10 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 				if (term.type && term.type !== 'survival') uses.add('plot')
 				if (hasAllowedChildTypes(child_types, ['survival'])) uses.add('branch')
 				return uses
+			} else {
+				if (graphableTypes.has(term.type)) uses.add('plot')
+				if (!term.isleaf) uses.add('branch')
+				return uses
 			}
 
 		case 'matrix':
@@ -110,6 +114,13 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 					uses.add('plot')
 				}
 				if (hasNumericChild(child_types)) uses.add('branch')
+			} else if (usecase?.vocab?.type == 'singleCell') {
+				/** TODO: Revisit this approach. Seems chaotic.  */
+				if (term.type && term.type.startsWith('singleCell')) {
+					if (term.plot && term.plot == usecase.vocab?.config.name) {
+						uses.add('plot')
+					}
+				}
 			} else {
 				if (graphableTypes.has(term.type)) uses.add('plot')
 				if (!term.isleaf) uses.add('branch')
@@ -142,7 +153,7 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 			}
 			return uses
 
-		case 'numericTermCollections':
+		case 'termCollections':
 			if (usecase.detail?.termIds?.includes(term.id)) uses.add('plot')
 			if (usecase.detail?.branchIds?.includes(term.id)) uses.add('branch')
 			return uses
@@ -173,6 +184,7 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 				if (hasAllowedChildTypes(child_types, ['condition', 'survival'])) uses.add('branch')
 				return uses
 			}
+			return uses
 
 		case 'survival':
 			if (usecase.detail == 'term') {
@@ -185,6 +197,7 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 				if (hasAllowedChildTypes(child_types, ['survival'])) uses.add('branch')
 				return uses
 			}
+			return uses
 
 		case 'regression':
 			if (usecase.detail == 'outcome') {
@@ -210,8 +223,9 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 				if (hasChildTypes(child_types, ['categorical', 'float', 'integer'])) uses.add('branch')
 				return uses
 			}
+			return uses
 
-		case 'filter':
+		case 'filter': {
 			// apply "exlst" to other targets as needed
 			const exlst = termdbConfig?.excludedTermtypeByTarget?.filter
 			if (exlst) {
@@ -219,7 +233,11 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 				if (child_types.find(t => !exlst.includes(t))) uses.add('branch') // there's a non-excluded child type, allow branch to show
 				return uses
 			}
-		// no specific rule for filter. pass and use default rules
+			// no specific rule for filter. use default rules
+			if (graphableTypes.has(term.type)) uses.add('plot')
+			if (!term.isleaf) uses.add('branch')
+			return uses
+		}
 
 		case 'correlationVolcano':
 			if (usecase.detail == 'numeric') {

package/src/terms.js

@@ -3,6 +3,7 @@ import {
 	dtssgsea,
 	dtdnamethylation,
 	dtmetaboliteintensity,
+	dtwholeproteomeabundance,
 	TermTypeGroups,
 	dtTerms
 } from './common.js'
@@ -44,6 +45,7 @@ export const TermTypes = {
 	SURVIVAL: 'survival',
 	SAMPLELST: 'samplelst',
 	METABOLITE_INTENSITY: 'metaboliteIntensity',
+	WHOLE_PROTEOME_ABUNDANCE: 'wholeProteomeAbundance',
 	SINGLECELL_GENE_EXPRESSION: 'singleCellGeneExpression',
 	SINGLECELL_CELLTYPE: 'singleCellCellType',
 	MULTIVALUE: 'multivalue',
@@ -61,7 +63,8 @@ export const TermTypes2Dt = {
 	[TermTypes.GENE_EXPRESSION]: dtgeneexpression,
 	[TermTypes.SSGSEA]: dtssgsea,
 	[TermTypes.DNA_METHYLATION]: dtdnamethylation,
-	[TermTypes.METABOLITE_INTENSITY]: dtmetaboliteintensity
+	[TermTypes.METABOLITE_INTENSITY]: dtmetaboliteintensity,
+	[TermTypes.WHOLE_PROTEOME_ABUNDANCE]: dtwholeproteomeabundance
 }
 
 // maps term type to group (as is shown as toggles in search ui)
@@ -80,8 +83,10 @@ export const typeGroup = {
 	[TermTypes.SSGSEA]: TermTypeGroups.SSGSEA,
 	[TermTypes.DNA_METHYLATION]: TermTypeGroups.DNA_METHYLATION,
 	[TermTypes.METABOLITE_INTENSITY]: TermTypeGroups.METABOLITE_INTENSITY,
+	[TermTypes.WHOLE_PROTEOME_ABUNDANCE]: TermTypeGroups.WHOLE_PROTEOME_ABUNDANCE,
 	[TermTypes.TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION,
-	[TermTypes.SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE
+	[TermTypes.SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE,
+	[TermTypes.SINGLECELL_GENE_EXPRESSION]: TermTypeGroups.SINGLECELL_GENE_EXPRESSION
 }
 
 const nonDictTypes = new Set([
@@ -93,6 +98,7 @@ const nonDictTypes = new Set([
 	TermTypes.DNA_METHYLATION,
 	TermTypes.GENE_VARIANT,
 	TermTypes.METABOLITE_INTENSITY,
+	TermTypes.WHOLE_PROTEOME_ABUNDANCE,
 	TermTypes.SINGLECELL_GENE_EXPRESSION,
 	TermTypes.SINGLECELL_CELLTYPE
 ])
@@ -107,6 +113,7 @@ export const numericTypes = new Set([
 	TermTypes.SSGSEA,
 	TermTypes.DNA_METHYLATION,
 	TermTypes.METABOLITE_INTENSITY,
+	TermTypes.WHOLE_PROTEOME_ABUNDANCE,
 	TermTypes.SINGLECELL_GENE_EXPRESSION,
 	TermTypes.DATE
 ])
@@ -117,7 +124,7 @@ export const annoNumericTypes = new Set([TermTypes.INTEGER, TermTypes.FLOAT, Ter
 
 const categoricalTypes = new Set([TermTypes.CATEGORICAL, TermTypes.SNP])
 
-const singleSampleTerms = new Set([TermTypes.SINGLECELL_GENE_EXPRESSION])
+const singleSampleTerms = new Set([TermTypes.SINGLECELL_CELLTYPE, TermTypes.SINGLECELL_GENE_EXPRESSION])
 
 export function isSingleSampleTerm(term) {
 	if (!term) return false
@@ -154,6 +161,7 @@ export function equals(t1, t2) {
 		case TermTypes.DNA_METHYLATION:
 			return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop
 		case TermTypes.METABOLITE_INTENSITY:
+		case TermTypes.WHOLE_PROTEOME_ABUNDANCE:
 			return t1.name == t2.name
 		case TermTypes.GENE_VARIANT:
 			return t1.gene == t2.gene || (t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop)
@@ -231,6 +239,7 @@ const typeMap = {
 	dnaMethylation: 'DNA Methylation',
 	geneVariant: 'Gene Variant',
 	metaboliteIntensity: 'Metabolite Intensity',
+	wholeProteomeAbundance: 'Whole Proteome Abundance',
 	multiValue: 'Multi Value',
 	singleCellGeneExpression: 'Single Cell, Gene Expression',
 	singleCellCellType: 'Single Cell, Cell Type',