@sjcrh/proteinpaint-shared 2.178.0 → 2.179.0

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@sjcrh/proteinpaint-shared",
-  "version": "2.178.0",
+  "version": "2.179.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/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

@@ -1,4 +1,4 @@
-import { TermTypes, isNumericTerm } from './terms.js'
+import { TermTypes, isNumericTerm, SINGLECELL_CELLTYPE, SINGLECELL_GENE_EXPRESSION } from './terms.js'
 
 export const graphableTypes = new Set([
 	'categorical',
@@ -20,8 +20,8 @@ export const graphableTypes = new Set([
 	TermTypes.DNA_METHYLATION,
 	TermTypes.METABOLITE_INTENSITY,
 	TermTypes.WHOLE_PROTEOME_ABUNDANCE,
-	TermTypes.SINGLECELL_GENE_EXPRESSION,
-	TermTypes.SINGLECELL_CELLTYPE,
+	SINGLECELL_GENE_EXPRESSION,
+	SINGLECELL_CELLTYPE,
 	TermTypes.SNP,
 	TermTypes.TERM_COLLECTION
 ])
@@ -114,14 +114,17 @@ 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 {
+			}
+			// Commenting out for now. May need later for another single
+			// cell term. Revisit logic at that time.
+			// else if (usecase?.specialCase?.type == 'singleCell') {
+			// 		if (term.type && term.type.startsWith('singleCell')) {
+			// 			if (term.plot && term.plot == usecase.specialCase?.config.name) {
+			// 				uses.add('plot')
+			// 			}
+			// 		}
+			// }
+			else {
 				if (graphableTypes.has(term.type)) uses.add('plot')
 				if (!term.isleaf) uses.add('branch')
 			}

package/src/terms.js

@@ -28,29 +28,50 @@ export const NumericModes = {
 	discrete: 'discrete'
 }
 
+export const CATEGORICAL = 'categorical'
+export const CONDITION = 'condition'
+export const DATE = 'date'
+export const DNA_METHYLATION = 'dnaMethylation'
+export const FLOAT = 'float'
+export const GENE_VARIANT = 'geneVariant'
+export const GENE_EXPRESSION = 'geneExpression'
+export const INTEGER = 'integer'
+export const METABOLITE_INTENSITY = 'metaboliteIntensity'
+export const MULTIVALUE = 'multivalue'
+export const SAMPLELST = 'samplelst'
+export const SINGLECELL_CELLTYPE = 'singleCellCellType'
+export const SINGLECELL_GENE_EXPRESSION = 'singleCellGeneExpression'
+export const SNP = 'snp'
+export const SNP_LIST = 'snplst'
+export const SNP_LOCUS = 'snplocus'
+export const SSGSEA = 'ssGSEA'
+export const SURVIVAL = 'survival'
+export const TERM_COLLECTION = 'termCollection'
+export const WHOLE_PROTEOME_ABUNDANCE = 'wholeProteomeAbundance'
+
 //Term types should be used gradually using these constants instead of hardcoding the values,
-// eg: type == TermTypes.CATEGORICAL instead of type == 'categorical'
+// eg: type == CATEGORICAL instead of type == 'categorical'
 export const TermTypes = {
-	GENE_VARIANT: 'geneVariant',
-	GENE_EXPRESSION: 'geneExpression',
-	SSGSEA: 'ssGSEA',
-	DNA_METHYLATION: 'dnaMethylation',
-	CATEGORICAL: 'categorical',
-	INTEGER: 'integer',
-	FLOAT: 'float',
-	SNP: 'snp',
-	SNP_LIST: 'snplst',
-	SNP_LOCUS: 'snplocus',
-	CONDITION: 'condition',
-	SURVIVAL: 'survival',
-	SAMPLELST: 'samplelst',
-	METABOLITE_INTENSITY: 'metaboliteIntensity',
-	WHOLE_PROTEOME_ABUNDANCE: 'wholeProteomeAbundance',
-	SINGLECELL_GENE_EXPRESSION: 'singleCellGeneExpression',
-	SINGLECELL_CELLTYPE: 'singleCellCellType',
-	MULTIVALUE: 'multivalue',
-	DATE: 'date',
-	TERM_COLLECTION: 'termCollection'
+	GENE_VARIANT,
+	GENE_EXPRESSION,
+	SSGSEA,
+	DNA_METHYLATION,
+	CATEGORICAL,
+	INTEGER,
+	FLOAT,
+	SNP,
+	SNP_LIST,
+	SNP_LOCUS,
+	CONDITION,
+	SURVIVAL,
+	SAMPLELST,
+	METABOLITE_INTENSITY,
+	WHOLE_PROTEOME_ABUNDANCE,
+	SINGLECELL_CELLTYPE,
+	SINGLECELL_GENE_EXPRESSION,
+	MULTIVALUE,
+	DATE,
+	TERM_COLLECTION
 }
 export const dtTermTypes = new Set(dtTerms.map(t => t.type))
 for (const dtTermType of dtTermTypes) {
@@ -60,75 +81,77 @@ for (const dtTermType of dtTermTypes) {
 export const NUMERIC_DICTIONARY_TERM = 'numericDictTerm'
 
 export const TermTypes2Dt = {
-	[TermTypes.GENE_EXPRESSION]: dtgeneexpression,
-	[TermTypes.SSGSEA]: dtssgsea,
-	[TermTypes.DNA_METHYLATION]: dtdnamethylation,
-	[TermTypes.METABOLITE_INTENSITY]: dtmetaboliteintensity,
-	[TermTypes.WHOLE_PROTEOME_ABUNDANCE]: dtwholeproteomeabundance
+	[GENE_EXPRESSION]: dtgeneexpression,
+	[SSGSEA]: dtssgsea,
+	[DNA_METHYLATION]: dtdnamethylation,
+	[METABOLITE_INTENSITY]: dtmetaboliteintensity,
+	[WHOLE_PROTEOME_ABUNDANCE]: dtwholeproteomeabundance
 }
 
 // maps term type to group (as is shown as toggles in search ui)
 export const typeGroup = {
-	[TermTypes.CATEGORICAL]: TermTypeGroups.DICTIONARY_VARIABLES,
-	[TermTypes.CONDITION]: TermTypeGroups.DICTIONARY_VARIABLES,
-	[TermTypes.FLOAT]: TermTypeGroups.DICTIONARY_VARIABLES,
-	[TermTypes.INTEGER]: TermTypeGroups.DICTIONARY_VARIABLES,
-	[TermTypes.SAMPLELST]: TermTypeGroups.DICTIONARY_VARIABLES,
-	[TermTypes.SURVIVAL]: TermTypeGroups.DICTIONARY_VARIABLES,
-	[TermTypes.GENE_VARIANT]: TermTypeGroups.MUTATION_CNV_FUSION,
-	[TermTypes.SNP]: TermTypeGroups.SNP,
-	[TermTypes.SNP_LIST]: TermTypeGroups.SNP_LIST,
-	[TermTypes.SNP_LOCUS]: TermTypeGroups.SNP_LOCUS,
-	[TermTypes.GENE_EXPRESSION]: TermTypeGroups.GENE_EXPRESSION,
-	[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_GENE_EXPRESSION]: TermTypeGroups.SINGLECELL_GENE_EXPRESSION
+	[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,
+	[GENE_VARIANT]: TermTypeGroups.MUTATION_CNV_FUSION,
+	[SNP]: TermTypeGroups.SNP,
+	[SNP_LIST]: TermTypeGroups.SNP_LIST,
+	[SNP_LOCUS]: TermTypeGroups.SNP_LOCUS,
+	[GENE_EXPRESSION]: TermTypeGroups.GENE_EXPRESSION,
+	[SSGSEA]: TermTypeGroups.SSGSEA,
+	[DNA_METHYLATION]: TermTypeGroups.DNA_METHYLATION,
+	[METABOLITE_INTENSITY]: TermTypeGroups.METABOLITE_INTENSITY,
+	[WHOLE_PROTEOME_ABUNDANCE]: TermTypeGroups.WHOLE_PROTEOME_ABUNDANCE,
+	[TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION,
+	[SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE,
+	[SINGLECELL_GENE_EXPRESSION]: TermTypeGroups.SINGLECELL_GENE_EXPRESSION
 }
 
 const nonDictTypes = new Set([
-	TermTypes.SNP,
-	TermTypes.SNP_LIST,
-	TermTypes.SNP_LOCUS,
-	TermTypes.GENE_EXPRESSION,
-	TermTypes.SSGSEA,
-	TermTypes.DNA_METHYLATION,
-	TermTypes.GENE_VARIANT,
-	TermTypes.METABOLITE_INTENSITY,
-	TermTypes.WHOLE_PROTEOME_ABUNDANCE,
-	TermTypes.SINGLECELL_GENE_EXPRESSION,
-	TermTypes.SINGLECELL_CELLTYPE
+	SNP,
+	SNP_LIST,
+	SNP_LOCUS,
+	GENE_EXPRESSION,
+	SSGSEA,
+	DNA_METHYLATION,
+	GENE_VARIANT,
+	METABOLITE_INTENSITY,
+	WHOLE_PROTEOME_ABUNDANCE,
+	SINGLECELL_CELLTYPE,
+	SINGLECELL_GENE_EXPRESSION
 ])
+
 for (const dtTermType of dtTermTypes) {
 	nonDictTypes.add(TermTypes[dtTermType.toUpperCase()])
 }
 
 export const numericTypes = new Set([
-	TermTypes.INTEGER,
-	TermTypes.FLOAT,
-	TermTypes.GENE_EXPRESSION,
-	TermTypes.SSGSEA,
-	TermTypes.DNA_METHYLATION,
-	TermTypes.METABOLITE_INTENSITY,
-	TermTypes.WHOLE_PROTEOME_ABUNDANCE,
-	TermTypes.SINGLECELL_GENE_EXPRESSION,
-	TermTypes.DATE
+	INTEGER,
+	FLOAT,
+	GENE_EXPRESSION,
+	SSGSEA,
+	DNA_METHYLATION,
+	METABOLITE_INTENSITY,
+	WHOLE_PROTEOME_ABUNDANCE,
+	SINGLECELL_GENE_EXPRESSION,
+	DATE
 ])
 
 // available termdb numeric table names used as anno_<term.type>,
 // for example anno_integer, anno_float, anno_date
-export const annoNumericTypes = new Set([TermTypes.INTEGER, TermTypes.FLOAT, TermTypes.DATE])
+export const annoNumericTypes = new Set([INTEGER, FLOAT, DATE])
 
-const categoricalTypes = new Set([TermTypes.CATEGORICAL, TermTypes.SNP])
+const categoricalTypes = new Set([CATEGORICAL, SNP])
 
-const singleSampleTerms = new Set([TermTypes.SINGLECELL_CELLTYPE, TermTypes.SINGLECELL_GENE_EXPRESSION])
+const singleCellTerms = new Set([SINGLECELL_CELLTYPE, SINGLECELL_GENE_EXPRESSION])
 
-export function isSingleSampleTerm(term) {
+export function isSingleCellTerm(term) {
 	if (!term) return false
-	return singleSampleTerms.has(term.type)
+	return singleCellTerms.has(term.type)
 }
 export function isNumericTerm(term) {
 	if (!term) return false
@@ -152,24 +175,24 @@ export 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 //term types are different
-	if (isDictionaryType(t1.type) && isDictionaryType(t2.type) && t1.type != TermTypes.SAMPLELST) return t1.id === t2.id
+	if (isDictionaryType(t1.type) && isDictionaryType(t2.type) && t1.type != SAMPLELST) return t1.id === t2.id
 	switch (t1.type) {
-		case TermTypes.GENE_EXPRESSION:
+		case GENE_EXPRESSION:
 			return t1.gene == t2.gene
-		case TermTypes.SSGSEA:
+		case SSGSEA:
 			return t1.id == t2.id
-		case TermTypes.DNA_METHYLATION:
+		case DNA_METHYLATION:
 			return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop
-		case TermTypes.METABOLITE_INTENSITY:
-		case TermTypes.WHOLE_PROTEOME_ABUNDANCE:
+		case METABOLITE_INTENSITY:
+		case WHOLE_PROTEOME_ABUNDANCE:
 			return t1.name == t2.name
-		case TermTypes.GENE_VARIANT:
+		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 TermTypes.SNP_LIST:
-		// case TermTypes.SNP_LOCUS:
-		// case TermTypes.SAMPLELST:
+		// case SNP_LIST:
+		// case SNP_LOCUS:
+		// case SAMPLELST:
 
 		default:
 			return false