@sjcrh/proteinpaint-shared 2.113.0 → 2.115.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-shared",
-  "version": "2.113.0",
+  "version": "2.115.0",
   "description": "ProteinPaint code that is shared between server and client-side workspaces",
   "type": "module",
   "main": "src/index.js",
@@ -11,7 +11,9 @@
   "scripts": {
     "build": "esbuild src/*.ts --platform=node --outdir=src/ --format=esm && prettier --no-semi --use-tabs --write src/urljson.js src/joinUrl.js src/doc.js",
     "prepack": "npm run build",
-    "test": "ls src/test/*.spec* | xargs node"
+    "pretest": "mkdir -p test && node emitImports > test/internals-test.ts",
+    "test": "tsx test/internals-test.ts",
+    "test-x": "ls src/test/*.spec* | xargs -I % bash -c '{ tsx %; sleep 0.001; }'"
   },
   "author": "",
   "license": "ISC",

package/src/common.js

@@ -11,6 +11,7 @@ exported functions
 import { rgb } from 'd3-color'
 import * as d3scale from 'd3-scale'
 import * as d3 from 'd3'
+import { getWrappedTvslst } from './filter.js'
 
 // moved from `#shared/terms` to here, so that this can be passed as
 // part of 'common' argument to exported dataset js function, at server runtime
@@ -1153,156 +1154,141 @@ export const CNVClasses = Object.values(mclass)
 	.filter(m => m.dt == dtcnv)
 	.map(m => m.key)
 
-/*
-Term groupsetting used for geneVariant term
-NOTE: for each groupsetting, groups[] is ordered by priority
-for example: in the 'Protein-changing vs. rest' groupsetting, the
-'Protein-changing' group is listed first in groups[] so that samples
-that have both missense and silent mutations are classified in the
-'Protein-changing' group
-*/
+// dt terms used for filtering variants for geneVariant term
+const _dtTerms = [
+	{
+		id: 'snvindel',
+		query: 'snvindel',
+		name: dt2label[dtsnvindel],
+		parent_id: null,
+		isleaf: true,
+		type: 'dtsnvindel',
+		dt: dtsnvindel,
+		values: Object.fromEntries(
+			mutationClasses.filter(key => key != 'Blank').map(key => [key, { label: mclass[key].label }])
+		)
+	},
+	{
+		id: 'cnv',
+		query: 'cnv',
+		name: dt2label[dtcnv],
+		parent_id: null,
+		isleaf: true,
+		type: 'dtcnv',
+		dt: dtcnv,
+		values: Object.fromEntries([...CNVClasses, 'WT'].map(key => [key, { label: mclass[key].label }]))
+	},
+	{
+		id: 'fusion',
+		query: 'svfusion',
+		name: dt2label[dtfusionrna],
+		parent_id: null,
+		isleaf: true,
+		type: 'dtfusion',
+		dt: dtfusionrna,
+		values: Object.fromEntries([mclassfusionrna, 'WT'].map(key => [key, { label: mclass[key].label }]))
+	},
+	{
+		id: 'sv',
+		query: 'svfusion',
+		name: dt2label[dtsv],
+		parent_id: null,
+		isleaf: true,
+		type: 'dtsv',
+		dt: dtsv,
+		values: Object.fromEntries([mclasssv, 'WT'].map(key => [key, { label: mclass[key].label }]))
+	}
+]
+// add origin annotations to dt terms
+export const dtTerms = []
+for (const _dtTerm of _dtTerms) {
+	const dtTerm = structuredClone(_dtTerm)
+	dtTerm.name_noOrigin = dtTerm.name // for labeling groups in groupsetting
+	dtTerms.push(dtTerm) // no origin
+	for (const origin of ['somatic', 'germline']) {
+		// add origins
+		const addOrigin = {
+			id: `${dtTerm.id}_${origin}`,
+			name: `${dtTerm.name} (${origin})`,
+			origin
+		}
+		dtTerms.push(Object.assign({}, dtTerm, addOrigin))
+	}
+}
+
+const dtFilter = {
+	opts: { joinWith: ['and', 'or'] },
+	terms: dtTerms
+}
+
+const groupsetLst = []
+for (const term of dtTerms) {
+	// wildtype filter
+	const WTfilter = structuredClone(dtFilter)
+	WTfilter.group = 2
+	const WT = 'WT'
+	const WTvalue = { key: WT, label: term.values[WT].label, value: WT }
+	const WTtvs = { type: 'tvs', tvs: { term, values: [WTvalue] } }
+	WTfilter.active = getWrappedTvslst([WTtvs])
+	let WTname = 'Wildtype'
+	// mutated filter
+	const MUTfilter = structuredClone(dtFilter)
+	MUTfilter.group = 1
+	const classes = Object.keys(term.values)
+	if (classes.length < 2) throw 'should have at least 2 classes'
+	let MUTtvs, MUTname
+	if (classes.length == 2) {
+		// only 2 classes
+		// mutant filter will filter for the mutant class
+		const MUT = classes.find(c => c != WT)
+		const MUTvalue = { key: MUT, label: term.values[MUT].label, value: MUT }
+		MUTtvs = { type: 'tvs', tvs: { term, values: [MUTvalue] } }
+		MUTname = term.values[MUT].label
+	} else {
+		// more than 2 classes
+		// mutant filter will filter for all non-wildtype classes
+		MUTtvs = { type: 'tvs', tvs: { term, values: [WTvalue], isnot: true } }
+		MUTname = term.name_noOrigin
+	}
+	MUTfilter.active = getWrappedTvslst([MUTtvs])
+	// excluded filter
+	const EXCLUDEfilter = structuredClone(dtFilter)
+	EXCLUDEfilter.group = 0
+	EXCLUDEfilter.active = getWrappedTvslst()
+	// assign filters to groups
+	let GRPSETname = `${MUTname} vs. Wildtype`
+	if (term.origin) GRPSETname += ` (${term.origin})`
+	const WTgroup = {
+		name: WTname,
+		type: 'filter',
+		uncomputable: false,
+		filter: WTfilter
+	}
+	const MUTgroup = {
+		name: MUTname,
+		type: 'filter',
+		uncomputable: false,
+		filter: MUTfilter
+	}
+	const EXCLUDEgroup = {
+		name: 'Excluded categories',
+		type: 'filter',
+		uncomputable: true,
+		filter: EXCLUDEfilter
+	}
+	// assign groups to groupset
+	const groupset = {
+		name: GRPSETname,
+		groups: [EXCLUDEgroup, MUTgroup, WTgroup],
+		id: term.id
+	}
+	groupsetLst.push(groupset)
+}
 
 export const geneVariantTermGroupsetting = {
 	disabled: false, // as const, // TODO: may need to add is when converting common.js to .ts
 	type: 'custom',
-	lst: [
-		{
-			// SNV/indel groupsetting
-			name: 'Mutated vs. wildtype',
-			groups: [
-				{
-					type: 'values', // as const, // TODO: may need to add is when converting common.js to .ts
-					name: 'Mutated',
-					values: mutationClasses
-						.filter(key => key != 'WT' && key != 'Blank')
-						.map(key => {
-							return { key, label: mclass[key].label }
-						})
-				},
-				{
-					type: 'values',
-					name: 'Wildtype',
-					values: [{ key: 'WT', label: 'Wildtype' }]
-				},
-				{
-					type: 'values',
-					name: 'Not tested',
-					values: [{ key: 'Blank', label: 'Not tested' }],
-					uncomputable: true
-				}
-			]
-		},
-		// SNV/indel groupsetting
-		{
-			name: 'Protein-changing vs. rest',
-			groups: [
-				{
-					type: 'values',
-					name: 'Protein-changing',
-					values: proteinChangingMutations.map(key => {
-						return { key, label: mclass[key].label }
-					})
-				},
-				{
-					type: 'values',
-					name: 'Rest',
-					values: Object.keys(mclass)
-						.filter(key => !proteinChangingMutations.includes(key) && key != 'Blank')
-						.map(key => {
-							return { key, label: mclass[key].label }
-						})
-				},
-				{
-					type: 'values',
-					name: 'Not tested',
-					values: [{ key: 'Blank', label: 'Not tested' }],
-					uncomputable: true
-				}
-			]
-		},
-		// SNV/indel groupsetting
-		{
-			name: 'Truncating vs. rest',
-			groups: [
-				{
-					type: 'values',
-					name: 'Truncating',
-					values: truncatingMutations.map(key => {
-						return { key, label: mclass[key].label }
-					})
-				},
-				{
-					type: 'values',
-					name: 'Rest',
-					values: Object.keys(mclass)
-						.filter(key => !truncatingMutations.includes(key) && key != 'Blank')
-						.map(key => {
-							return { key, label: mclass[key].label }
-						})
-				},
-				{
-					type: 'values',
-					name: 'Not tested',
-					values: [{ key: 'Blank', label: 'Not tested' }],
-					uncomputable: true
-				}
-			]
-		},
-		// CNV groupsetting
-		{
-			name: 'Gain vs. Loss vs. LOH vs. Wildtype',
-			groups: [
-				{
-					type: 'values',
-					name: 'Copy number gain',
-					values: [{ key: 'CNV_amp', label: mclass['CNV_amp'].label }]
-				},
-				{
-					type: 'values',
-					name: 'Copy number loss',
-					values: [{ key: 'CNV_loss', label: mclass['CNV_loss'].label }]
-				},
-				{
-					type: 'values',
-					name: 'LOH',
-					values: [{ key: 'CNV_loh', label: mclass['CNV_loh'].label }]
-				},
-				{
-					type: 'values',
-					name: 'Wildtype',
-					values: [{ key: 'WT', label: 'Wildtype' }]
-				},
-				{
-					type: 'values',
-					name: 'Not tested',
-					values: [{ key: 'Blank', label: 'Not tested' }],
-					uncomputable: true
-				}
-			]
-		},
-		// SV fusion groupsetting
-		{
-			name: 'Fusion vs. Wildtype',
-			groups: [
-				{
-					type: 'values',
-					name: 'Fusion transcript',
-					values: [{ key: 'Fuserna', label: mclass['Fuserna'].label }]
-				},
-				{
-					type: 'values',
-					name: 'Wildtype',
-					values: [{ key: 'WT', label: 'Wildtype' }]
-				},
-				{
-					type: 'values',
-					name: 'Not tested',
-					values: [{ key: 'Blank', label: 'Not tested' }],
-					uncomputable: true
-				}
-			]
-		}
-	]
+	lst: groupsetLst
 }
 
 export const colorScaleMap = {

package/src/filter.js

@@ -242,3 +242,14 @@ export function filterJoin(lst) {
 	}
 	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
+}

package/src/termdb.usecase.js

@@ -11,11 +11,17 @@ export const graphableTypes = new Set([
 	'geneVariant',
 	'samplelst',
 	'geneExpression',
+	'dtcnv',
+	'dtsnvindel',
+	'dtfusion',
+	'dtsv',
+	'date',
 	TermTypes.METABOLITE_INTENSITY,
 	TermTypes.SINGLECELL_GENE_EXPRESSION,
 	TermTypes.SINGLECELL_CELLTYPE,
 	TermTypes.SNP
 ])
+
 /*
 isUsableTerm() will
 

package/src/terms.js

@@ -1,4 +1,5 @@
 import { dtgeneexpression, dtmetaboliteintensity, TermTypeGroups } from './common.js'
+import { roundValueAuto } from './roundValue.js'
 
 // moved TermTypeGroups to `server/src/common.js`, so now has to re-export
 export { TermTypeGroups } from './common.js'
@@ -37,7 +38,8 @@ export const TermTypes = {
 	METABOLITE_INTENSITY: 'metaboliteIntensity',
 	SINGLECELL_GENE_EXPRESSION: 'singleCellGeneExpression',
 	SINGLECELL_CELLTYPE: 'singleCellCellType',
-	MULTIVALUE: 'multivalue'
+	MULTIVALUE: 'multivalue',
+	DATE: 'date'
 }
 
 export const NUMERIC_DICTIONARY_TERM = 'numericDictTerm'
@@ -80,7 +82,8 @@ export const numericTypes = new Set([
 	TermTypes.FLOAT,
 	TermTypes.GENE_EXPRESSION,
 	TermTypes.METABOLITE_INTENSITY,
-	TermTypes.SINGLECELL_GENE_EXPRESSION
+	TermTypes.SINGLECELL_GENE_EXPRESSION,
+	TermTypes.DATE
 ])
 
 const categoricalTypes = new Set([TermTypes.CATEGORICAL, TermTypes.SNP])
@@ -206,3 +209,37 @@ const typeMap = {
 export function termType2label(type) {
 	return typeMap[type] || 'Unknown term type'
 }
+
+/*
+Value is a decimal year.
+A decimal year is a way of expressing a date or time period as a year with a decimal part, where the decimal portion 
+represents the fraction of the year that has elapsed. 
+Example:
+2025.0 represents the beginning of the year 2025. 
+2025.5 represents the middle of the year 2025. 
+ */
+export function getDateStrFromNumber(value) {
+	const year = Math.floor(value)
+	const time = (value - year) * 365 * 24 * 60 * 60 * 1000 // convert to milliseconds
+	const january1st = new Date(year, 0, 0)
+	const date = new Date(january1st.getTime() + time)
+
+	//Omit day to  deidentify the patients
+	return date.toLocaleDateString('en-US', {
+		year: 'numeric',
+		month: 'long'
+	})
+}
+
+//The value returned is a decimal year
+//A decimal year is a way of expressing a date or time period as a year with a decimal part, where the decimal portion
+//represents the fraction of the year that has elapsed.
+export function getNumberFromDateStr(str) {
+	const date = new Date(str)
+	const year = date.getFullYear()
+	const january1st = new Date(year, 0, 0)
+	const diffTime = date - january1st
+	const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24))
+	const decimal = roundValueAuto(diffDays / 365)
+	return year + decimal
+}

package/src/time.js

@@ -0,0 +1,26 @@
+function formatElapsedTime(ms) {
+  if (typeof ms !== "number") {
+    return "Invalid time: not a number";
+  }
+  if (isNaN(ms)) {
+    return "Invalid time: NaN";
+  }
+  if (!isFinite(ms)) {
+    return ms > 0 ? "Infinite time" : "-Infinite time";
+  }
+  const absMs = Math.abs(ms);
+  const sign = ms < 0 ? "-" : "";
+  if (absMs < 1e3) {
+    return `${sign}${absMs}ms`;
+  } else if (absMs < 6e4) {
+    const seconds = (absMs / 1e3).toFixed(2);
+    return `${sign}${seconds}s`;
+  } else {
+    const minutes = Math.floor(absMs / 6e4);
+    const seconds = (absMs % 6e4 / 1e3).toFixed(2);
+    return `${sign}${minutes}m ${seconds}s`;
+  }
+}
+export {
+  formatElapsedTime
+};