@sjcrh/proteinpaint-shared 2.187.0 → 2.188.0

package/src/terms.js

@@ -1,341 +0,0 @@
-import {
-	dtgeneexpression,
-	dtssgsea,
-	dtdnamethylation,
-	dtmetaboliteintensity,
-	dtproteomeabundance,
-	TermTypeGroups,
-	dtTerms,
-} from "./common.js"
-import { TermTypeGroups as TermTypeGroups2 } from "./common.js"
-const ROOT_SAMPLE_TYPE = 1
-const DEFAULT_SAMPLE_TYPE = 2
-const NumericModes = {
-	continuous: "continuous",
-	discrete: "discrete",
-}
-const CATEGORICAL = "categorical"
-const CONDITION = "condition"
-const DATE = "date"
-const DNA_METHYLATION = "dnaMethylation"
-const FLOAT = "float"
-const GENE_VARIANT = "geneVariant"
-const GENE_EXPRESSION = "geneExpression"
-const ISOFORM_EXPRESSION = "isoformExpression"
-const INTEGER = "integer"
-const METABOLITE_INTENSITY = "metaboliteIntensity"
-const MULTIVALUE = "multivalue"
-const SAMPLELST = "samplelst"
-const SINGLECELL_CELLTYPE = "singleCellCellType"
-const SINGLECELL_GENE_EXPRESSION = "singleCellGeneExpression"
-const SNP = "snp"
-const SNP_LIST = "snplst"
-const SNP_LOCUS = "snplocus"
-const SSGSEA = "ssGSEA"
-const SURVIVAL = "survival"
-const TERM_COLLECTION = "termCollection"
-const PROTEOME_ABUNDANCE = "proteomeAbundance"
-const TermTypes = {
-	GENE_VARIANT,
-	GENE_EXPRESSION,
-	ISOFORM_EXPRESSION,
-	SSGSEA,
-	DNA_METHYLATION,
-	CATEGORICAL,
-	INTEGER,
-	FLOAT,
-	SNP,
-	SNP_LIST,
-	SNP_LOCUS,
-	CONDITION,
-	SURVIVAL,
-	SAMPLELST,
-	METABOLITE_INTENSITY,
-	PROTEOME_ABUNDANCE,
-	SINGLECELL_CELLTYPE,
-	SINGLECELL_GENE_EXPRESSION,
-	MULTIVALUE,
-	DATE,
-	TERM_COLLECTION,
-}
-const dtTermTypes = new Set(dtTerms.map((t) => t.type))
-for (const dtTermType of dtTermTypes) {
-	TermTypes[dtTermType.toUpperCase()] = dtTermType
-}
-const NUMERIC_DICTIONARY_TERM = "numericDictTerm"
-const TermTypes2Dt = {
-	[GENE_EXPRESSION]: dtgeneexpression,
-	[SSGSEA]: dtssgsea,
-	[DNA_METHYLATION]: dtdnamethylation,
-	[METABOLITE_INTENSITY]: dtmetaboliteintensity,
-	[PROTEOME_ABUNDANCE]: dtproteomeabundance,
-}
-const 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,
-	[SSGSEA]: TermTypeGroups.SSGSEA,
-	[DNA_METHYLATION]: TermTypeGroups.DNA_METHYLATION,
-	[METABOLITE_INTENSITY]: TermTypeGroups.METABOLITE_INTENSITY,
-	[PROTEOME_ABUNDANCE]: TermTypeGroups.PROTEOME_ABUNDANCE,
-	[TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION,
-	[SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE,
-	[SINGLECELL_GENE_EXPRESSION]: TermTypeGroups.SINGLECELL_GENE_EXPRESSION,
-}
-const nonDictTypes = /* @__PURE__ */ new Set([
-	SNP,
-	SNP_LIST,
-	SNP_LOCUS,
-	GENE_EXPRESSION,
-	ISOFORM_EXPRESSION,
-	SSGSEA,
-	DNA_METHYLATION,
-	GENE_VARIANT,
-	METABOLITE_INTENSITY,
-	PROTEOME_ABUNDANCE,
-	SINGLECELL_CELLTYPE,
-	SINGLECELL_GENE_EXPRESSION,
-])
-for (const dtTermType of dtTermTypes) {
-	nonDictTypes.add(TermTypes[dtTermType.toUpperCase()])
-}
-const numericTypes = /* @__PURE__ */ new Set([
-	INTEGER,
-	FLOAT,
-	GENE_EXPRESSION,
-	ISOFORM_EXPRESSION,
-	SSGSEA,
-	DNA_METHYLATION,
-	METABOLITE_INTENSITY,
-	PROTEOME_ABUNDANCE,
-	SINGLECELL_GENE_EXPRESSION,
-	DATE,
-])
-const annoNumericTypes = /* @__PURE__ */ new Set([INTEGER, FLOAT, DATE])
-const categoricalTypes = /* @__PURE__ */ new Set([CATEGORICAL, SNP])
-const singleCellTerms = /* @__PURE__ */ new Set([
-	SINGLECELL_CELLTYPE,
-	SINGLECELL_GENE_EXPRESSION,
-])
-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 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 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 getBin(lst, value) {
-	let bin = lst.findIndex(
-		(b) =>
-			(b.startunbounded && value < b.stop) ||
-			(b.startunbounded && b.stopinclusive && value == b.stop)
-	)
-	if (bin == -1)
-		bin = lst.findIndex(
-			(b) =>
-				(b.stopunbounded && value > b.start) ||
-				(b.stopunbounded && b.startinclusive && value == b.start)
-		)
-	if (bin == -1)
-		bin = lst.findIndex(
-			(b) =>
-				(value > b.start && value < b.stop) ||
-				(b.startinclusive && value == b.start) ||
-				(b.stopinclusive && value == b.stop)
-		)
-	return bin
-}
-function getSampleType(term, ds) {
-	if (!term) return null
-	if (term.type && isNonDictionaryType(term.type)) return DEFAULT_SAMPLE_TYPE
-	if (term.id) return ds.cohort.termdb.term2SampleType.get(term.id)
-	if (term.type == "samplelst") {
-		const key = Object.keys(term.values)[0]
-		const sampleId = term.values[key].list[0]?.sampleId
-		if (sampleId) return ds.sampleId2Type.get(Number(sampleId) || sampleId)
-		else return DEFAULT_SAMPLE_TYPE
-	}
-	return DEFAULT_SAMPLE_TYPE
-}
-function getParentType(types, ds) {
-	if (Object.keys(ds.cohort.termdb.sampleTypes).length == 0) return null
-	const ids = Array.from(types)
-	if (!ids || ids.length == 0) return null
-	for (const id of ids) {
-		const typeObj = ds.cohort.termdb.sampleTypes[id]
-		if (!typeObj) continue
-		if (typeObj.parent_id == null) return id
-		if (ids.includes(typeObj.parent_id)) continue
-		else return typeObj.parent_id
-	}
-	return null
-}
-const typeMap = {
-	categorical: "Categorical",
-	condition: "Condition",
-	float: "Numerical",
-	integer: "Numerical",
-	geneExpression: "Gene Expression",
-	isoformExpression: "Isoform Expression",
-	ssGSEA: "Geneset Expression",
-	dnaMethylation: "DNA Methylation",
-	geneVariant: "Gene Variant",
-	metaboliteIntensity: "Metabolite Intensity",
-	proteomeAbundance: "Proteome Abundance",
-	multivalue: "Multi Value",
-	singleCellGeneExpression: "Single Cell, Gene Expression",
-	singleCellCellType: "Single Cell, Cell Type",
-	snplocus: "SNP Locus",
-	snp: "SNP",
-	snplst: "SNP List",
-	numericDictTerm: "Numeric Dictionary Term",
-	termCollection: "Term Collection",
-}
-function termType2label(type) {
-	return typeMap[type] || "Unknown term type"
-}
-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
-}
-const oneDayTime = 24 * 60 * 60 * 1e3
-function getDateStrFromNumber(value) {
-	const date = getDateFromNumber(value)
-	return date.toLocaleDateString("en-US", {
-		year: "numeric",
-		month: "long",
-	})
-}
-function getNumberFromDateStr(str) {
-	const date = new Date(str)
-	return getNumberFromDate(date)
-}
-function getNumberFromDate(date) {
-	const year = date.getFullYear()
-	const january1st = new Date(year, 0, 1)
-	const diffDays = (date.getTime() - january1st.getTime()) / oneDayTime
-	const daysTotal = getDaysInYear(year)
-	const decimal = diffDays / daysTotal
-	return year + decimal
-}
-function getDaysInYear(year) {
-	const isLeap = new Date(year, 1, 29).getMonth() === 1
-	const days = isLeap ? 366 : 365
-	return days
-}
-export {
-	CATEGORICAL,
-	CONDITION,
-	DATE,
-	DEFAULT_SAMPLE_TYPE,
-	DNA_METHYLATION,
-	FLOAT,
-	GENE_EXPRESSION,
-	GENE_VARIANT,
-	INTEGER,
-	ISOFORM_EXPRESSION,
-	METABOLITE_INTENSITY,
-	MULTIVALUE,
-	NUMERIC_DICTIONARY_TERM,
-	NumericModes,
-	PROTEOME_ABUNDANCE,
-	ROOT_SAMPLE_TYPE,
-	SAMPLELST,
-	SINGLECELL_CELLTYPE,
-	SINGLECELL_GENE_EXPRESSION,
-	SNP,
-	SNP_LIST,
-	SNP_LOCUS,
-	SSGSEA,
-	SURVIVAL,
-	TERM_COLLECTION,
-	TermTypeGroups2 as TermTypeGroups,
-	TermTypes,
-	TermTypes2Dt,
-	annoNumericTypes,
-	dtTermTypes,
-	equals,
-	getBin,
-	getDateFromNumber,
-	getDateStrFromNumber,
-	getDaysInYear,
-	getNumberFromDate,
-	getNumberFromDateStr,
-	getParentType,
-	getSampleType,
-	isCategoricalTerm,
-	isDictionaryType,
-	isNonDictionaryType,
-	isNumTermCollection,
-	isNumericTerm,
-	isSingleCellTerm,
-	numericTypes,
-	termType2label,
-	typeGroup,
-}

package/src/time.js

@@ -1,22 +0,0 @@
-function formatElapsedTime(ms, precision = 2) {
-	if (typeof ms !== "number" || isNaN(ms)) {
-		return typeof ms !== "number"
-			? "Invalid time: not a number"
-			: "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`
-	}
-	if (absMs < 6e4) {
-		return `${sign}${(absMs / 1e3).toFixed(precision)}s`
-	}
-	const minutes = Math.floor(absMs / 6e4)
-	const seconds = ((absMs % 6e4) / 1e3).toFixed(precision)
-	return `${sign}${minutes}m ${seconds}s`
-}
-export { formatElapsedTime }

package/src/tree.js

@@ -1,138 +0,0 @@
-/*
-input:
-1. list of leaf nodes, e.g. mutation cases, each with a set of key-value pairs
-2. levels of hierarchy in an ordered list
-   each item: { k, full }
-   "k" and "full" are two attribute keys
-
-output:
-a list of items, as input for d3-hierarchy.stratify
-one item for each child-parent relationship in the hierarchy
-{
-	id:
-	parentId:
-	lst:
-	value:
-	name:
-	full:
-	id0:
-	v0:
-	id1:
-	v1:
-	id2:
-	v2:
-}
-
-strange issue: https://github.com/stjude/proteinpaint/commit/c36004d47d4374d2ade719c6ef9e2b848f0850dc
-using Map for lp, nodes etc will cause memory issue, thus the use of simple objects
-
-to-do: verify this works after a reorg
-*/
-
-const hardcode_root = "root"
-const hierarchy_spacer = "..."
-
-export function stratinput(lst, levels) {
-	const lp = Object.create(null)
-	// leaf to parent
-	// k: HM...BALL...sub
-	// v: HM...BALL
-
-	const nodes = Object.create(null)
-	/*
-	k: string id of node, e.g. HM...BALL
-	v: node
-		.full
-		.lst[]
-			items from input
-	*/
-
-	const size = Object.create(null)
-	// only increment size to leaf nodes, so that root.sum() will work
-	// k: string id of a node, e.g. HM...BALL
-	// v: number of items
-
-	for (const m of lst) {
-		for (const [i, lev] of levels.entries()) {
-			const thisv = getkey(m, i, levels)
-			const pav = getkey(m, i - 1, levels)
-
-			// as mutations can come as {"subtype":""}
-			// in the sunburst chart at the subtype level, this mutation should not be counted
-			// thus the test with !m[lev.k] rather than !(lev.k in m)
-			if (!m[lev.k]) {
-				// stop at this level
-				// add count to prev level
-				if (i > 0) {
-					size[pav] += 1
-				}
-				break
-			}
-
-			lp[thisv] = pav
-			if (!(thisv in size)) {
-				size[thisv] = 0
-			}
-			if (!(thisv in nodes)) {
-				const n = {
-					lst: [],
-				}
-				if (lev.full) {
-					n.full = m[lev.full]
-				}
-
-				n.id0 = levels[0].k
-				n.v0 = m[levels[0].k]
-				if (i == 1) {
-					n.id1 = levels[1].k
-					n.v1 = m[levels[1].k]
-				}
-				if (i == 2) {
-					n.id2 = levels[2].k
-					n.v1 = m[levels[2].k]
-				}
-
-				nodes[thisv] = n
-			}
-			nodes[thisv].lst.push(m)
-			if (i == levels.length - 1) {
-				size[thisv] += 1
-			}
-		}
-	}
-
-	const nlst = [{ id: hardcode_root, name: hardcode_root }]
-
-	for (const chid in lp) {
-		const paid = lp[chid]
-		const n = nodes[chid]
-		const fields = chid.split(hierarchy_spacer)
-		nlst.push({
-			id: chid,
-			parentId: paid,
-			lst: n.lst,
-			value: size[chid],
-			name: fields[fields.length - 1], // show this instead of chid
-			full: n.full,
-			id0: n.id0,
-			v0: n.v0,
-			id1: n.id1,
-			v1: n.v1,
-			id2: n.id2,
-			v2: n.v2,
-		})
-	}
-	return nlst
-}
-
-function getkey(m, i, levels) {
-	// if i is 0, return 'root'
-	const klst = [hardcode_root]
-	for (let j = 0; j < i; j++) {
-		klst.push(m[levels[j].k])
-	}
-	if (i >= 0) {
-		klst.push(m[levels[i].k])
-	}
-	return klst.join(hierarchy_spacer)
-}

package/src/urljson.js

@@ -1,41 +0,0 @@
-import { isNumeric } from "./helpers.js"
-const reserved = ["false", "true", "null", "undefined"]
-const delimiters = ['"', "{", "["]
-function encode(rawObject) {
-	const params = []
-	for (const [key, value] of Object.entries(rawObject)) {
-		if (
-			typeof value == "string" &&
-			!isNumeric(value) &&
-			!reserved.includes(value) &&
-			!delimiters.includes(value[0])
-		) {
-			params.push(`${key}=${encodeURIComponent(value)}`)
-		} else if (value !== void 0) {
-			params.push(`${key}=${encodeURIComponent(JSON.stringify(value))}`)
-		}
-	}
-	return params.join("&")
-}
-function decode(query) {
-	const encoding = query.encoding
-	for (const [key, value] of Object.entries(query)) {
-		if (
-			encoding == "json" ||
-			value == "null" || // not new, always been
-			value == "true" || // NEED TO FIND-REPLACE CODE THAT USES value == 'true'
-			value == "false" || // NEED TO FIND-REPLACE CODE THAT USES value == 'false'
-			isNumeric(value) || // NEED TO check
-			(typeof value == "string" &&
-				value.startsWith('"') &&
-				value.endsWith('"')) ||
-			(typeof value == "string" &&
-				value.startsWith("{") &&
-				value.endsWith("}")) ||
-			(typeof value == "string" && value.startsWith("[") && value.endsWith("]"))
-		)
-			query[key] = JSON.parse(value)
-	}
-	return query
-}
-export { decode, encode }

package/src/vcf.ann.js

@@ -1,62 +0,0 @@
-import { vepinfo } from "./common.js"
-
-export function parse_ANN(str, header, m) {
-	// snpEff
-	if (!header) {
-		return null
-	}
-	for (const thisannotation of str.split(",")) {
-		const lst = thisannotation.replace(/&/g, ",").split("|")
-
-		const o = {}
-
-		for (let i = 0; i < header.length; i++) {
-			if (lst[i]) {
-				o[header[i].name] = lst[i]
-			}
-		}
-		if (!o.Allele) {
-			continue
-		}
-		let allele = null
-		for (const a of m.alleles) {
-			if (a.allele == o.Allele) {
-				allele = a
-				break
-			}
-		}
-		if (!allele) {
-			// cannot match to allele!!!
-			continue
-		}
-		if (!allele.ann) {
-			allele.ann = []
-		}
-		allele.ann.push(o)
-		o._gene = o.Gene_Name
-		// isoform
-		if (o.Feature_Type && o.Feature_Type == "transcript" && o.Feature_ID) {
-			o._isoform = o.Feature_ID.split(".")[0]
-		}
-		// class
-		if (o.Annotation) {
-			const [dt, cls, rank] = vepinfo(o.Annotation)
-			o._dt = dt
-			o._class = cls
-			o._csqrank = rank
-		} else {
-			// FIXME
-			o._dt = dtsnvindel
-			o._class = mclassnonstandard
-		}
-		// mname
-		if (o["HGVS.p"]) {
-			//o._mname=decodeURIComponent(o.HGVSp.substr(o.HGVSp.indexOf(':')+1))
-			o._mname = o["HGVS.p"]
-		} else if (o["HGVS.c"]) {
-			o._mname = o["HGVS.c"]
-		} else {
-		}
-	}
-	return true
-}