@sjcrh/proteinpaint-shared 2.186.0 → 2.188.0

package/src/bulk.sv.js

@@ -1,276 +0,0 @@
-import * as bulk from "./bulk.js"
-import * as common from "./common.js"
-
-/////////////////////////////////
-//
-// client/server shared
-//
-/////////////////////////////////
-
-// work for both sv/fusion
-// must tell if the data is fusion or sv
-
-export function parseheader(line, flag, issv) {
-	const header = line.toLowerCase().split("\t")
-	if (header.length <= 1) return "invalid file header for fusions"
-	const htry = (...lst) => {
-		for (const a of lst) {
-			const j = header.indexOf(a)
-			if (j != -1) return j
-		}
-		return -1
-	}
-	let i = htry("gene_a", "gene1", "genea")
-	if (i == -1) return "gene_a missing from header"
-	header[i] = "gene1"
-	i = htry("gene_b", "gene2", "geneb")
-	if (i == -1) return "gene_b missing from header"
-	header[i] = "gene2"
-	i = htry("chr_a", "chr1", "chra")
-	if (i == -1) return "chr_a missing from header"
-	header[i] = "chr1"
-	i = htry("chr_b", "chr2", "chrb")
-	if (i == -1) return "chr_b missing from header"
-	header[i] = "chr2"
-	i = htry("pos_a", "position_a", "position1", "posa")
-	if (i == -1) return "pos_a missing from header"
-	header[i] = "position1"
-	i = htry("pos_b", "position_b", "position2", "posb")
-	if (i == -1) return "pos_b missing from header"
-	header[i] = "position2"
-	i = htry("isoform_a", "refseq_a", "refseq1", "isoform1", "sv_refseqa")
-	if (i == -1) return "isoform_a missing from header"
-	header[i] = "isoform1"
-	i = htry("isoform_b", "refseq_b", "refseq2", "isoform2", "sv_refseqb")
-	if (i == -1) return "isoform_b missing from header"
-	header[i] = "isoform2"
-	i = htry("strand_a", "orta")
-	if (i == -1) return "strand_a missing from header"
-	header[i] = "strand1"
-	i = htry("strand_b", "ortb")
-	if (i == -1) return "strand_b missing from header"
-	header[i] = "strand2"
-	// optional
-	i = htry("sample", "sample_name", "tumor_sample_barcode")
-	if (i != -1) header[i] = "sample"
-	i = htry("patient", "donor", "target_case_id")
-	if (i != -1) header[i] = "patient"
-	i = htry("sampletype", "sample type", "sample_type")
-	if (i != -1) header[i] = "sampletype"
-	i = htry("disease")
-	if (i != -1) header[i] = "disease"
-	i = htry("origin")
-	if (i != -1) header[i] = "origin"
-	if (issv) {
-		flag.sv.loaded = true
-		flag.sv.header = header
-	} else {
-		flag.fusion.loaded = true
-		flag.fusion.header = header
-	}
-	return false
-}
-
-export function parseline(i, line, flag, issv) {
-	if (line == "" || line[0] == "#") return
-	const lst = line.split("\t")
-	const m = {}
-	const header = issv ? flag.sv.header : flag.fusion.header
-	const badlines = issv ? flag.sv.badlines : flag.fusion.badlines
-
-	for (let j = 0; j < header.length; j++) {
-		m[header[j]] = lst[j]
-	}
-	if (!m.chr1) {
-		badlines.push([i, "missing chr1", lst])
-		return
-	}
-	if (m.chr1.toLowerCase().indexOf("chr") != 0) {
-		m.chr1 = "chr" + m.chr1
-	}
-	if (!m.chr2) {
-		badlines.push([i, "missing chr2", lst])
-		return
-	}
-	if (m.chr2.toLowerCase().indexOf("chr") != 0) {
-		m.chr2 = "chr" + m.chr2
-	}
-	let v = m.position1
-	if (!v) {
-		badlines.push([i, "missing position1", lst])
-		return
-	}
-	let v2 = Number.parseInt(v)
-	if (Number.isNaN(v2) || v2 <= 0) {
-		badlines.push([i, "invalid value for position1", lst])
-		return
-	}
-	m.position1 = v2
-	v = m.position2
-	if (!v) {
-		badlines.push([i, "missing position2", lst])
-		return
-	}
-	v2 = Number.parseInt(v)
-	if (Number.isNaN(v2) || v2 <= 0) {
-		badlines.push([i, "invalid value for position2", lst])
-		return
-	}
-	m.position2 = v2
-	if (bulk.parsesample(m, flag, i, lst, badlines)) {
-		return
-	}
-	if (m.isoform1 && m.isoform1.indexOf(",") != -1) {
-		const lst2 = m.isoform1.split(",")
-		m.isoform1 = undefined
-		for (const t of lst2) {
-			if (t != "") m.isoform1 = t
-		}
-	}
-	if (m.isoform2 && m.isoform2.indexOf(",") != -1) {
-		const lst2 = m.isoform2.split(",")
-		m.isoform2 = undefined
-		for (const t of lst2) {
-			if (t != "") m.isoform2 = t
-		}
-	}
-	if (!m.gene1) {
-		m.isoform1 = undefined
-	}
-	if (!m.gene2) {
-		m.isoform2 = undefined
-	}
-	if (m.gene1) {
-		// put data under gene1
-		flag.good++
-		const m2 = {
-			dt: issv ? common.dtsv : common.dtfusionrna,
-			class: issv ? common.mclasssv : common.mclassfusionrna,
-			isoform: m.isoform1,
-			mname: m.gene2 || m.chr2,
-			sample: m.sample,
-			patient: m.patient,
-			sampletype: m.sampletype,
-			origin: m.origin,
-			disease: m.disease,
-			pairlst: [
-				{
-					a: {
-						name: m.gene1,
-						isoform: m.isoform1,
-						strand: m.strand1,
-						chr: m.chr1,
-						position: m.position1,
-					},
-					b: {
-						name: m.gene2,
-						isoform: m.isoform2,
-						strand: m.strand2,
-						chr: m.chr2,
-						position: m.position2,
-					},
-				},
-			],
-		}
-		const n = flag.geneToUpper ? m.gene1.toUpperCase() : m.gene1
-		if (!flag.data[n]) {
-			flag.data[n] = []
-		}
-		flag.data[n].push(m2)
-	}
-	if (m.gene2 && m.gene2 != m.gene1) {
-		// put data under gene2
-		flag.good++
-		const m2 = {
-			dt: issv ? common.dtsv : common.dtfusionrna,
-			class: issv ? common.mclasssv : common.mclassfusionrna,
-			isoform: m.isoform2,
-			mname: m.gene1 || m.chr1,
-			sample: m.sample,
-			patient: m.patient,
-			sampletype: m.sampletype,
-			origin: m.origin,
-			disease: m.disease,
-			pairlst: [
-				{
-					a: {
-						name: m.gene1,
-						isoform: m.isoform1,
-						strand: m.strand1,
-						chr: m.chr1,
-						position: m.position1,
-					},
-					b: {
-						name: m.gene2,
-						isoform: m.isoform2,
-						strand: m.strand2,
-						chr: m.chr2,
-						position: m.position2,
-					},
-				},
-			],
-		}
-		const n = flag.geneToUpper ? m.gene2.toUpperCase() : m.gene2
-		if (!flag.data[n]) {
-			flag.data[n] = []
-		}
-		flag.data[n].push(m2)
-	}
-}
-
-export function duplicate(m) {
-	const n = {}
-	for (const k in m) {
-		if (k == "pairlst") continue
-		const v = m[k]
-		const type = typeof v
-		if (type == "object") {
-			continue
-		}
-		n[k] = v
-	}
-	if (m.pairlst) {
-		n.pairlst = []
-		for (const pair of m.pairlst) {
-			const p = {}
-			for (const k in pair) {
-				if (k == "a" || k == "b" || k == "interstitial") {
-					continue
-				}
-				p[k] = pair[k]
-			}
-			if (pair.a) {
-				p.a = {}
-				for (const k in pair.a) {
-					const v = pair.a[k]
-					if (typeof v == "object") {
-						continue
-					}
-					p.a[k] = v
-				}
-			}
-			if (pair.b) {
-				p.b = {}
-				for (const k in pair.b) {
-					const v = pair.b[k]
-					if (typeof v == "object") {
-						continue
-					}
-					p.b[k] = v
-				}
-			}
-			if (pair.interstitial) {
-				p.interstitial = {}
-				for (const k in pair.interstitial) {
-					const v = pair.interstitial[k]
-					if (typeof v == "object") {
-						continue
-					}
-					p.interstitial[k] = v
-				}
-			}
-			n.pairlst.push(p)
-		}
-	}
-	return n
-}

package/src/bulk.svjson.js

@@ -1,164 +0,0 @@
-/////////////////////////////////
-//
-// client/server shared
-//
-/////////////////////////////////
-
-import * as common from "./common.js"
-import * as bulk from "./bulk.js"
-
-// work for both sv/fusion
-// must tell if the data is fusion or sv
-
-export function parseheader(line, flag) {
-	const header = line.toLowerCase().split("\t")
-	if (header.length <= 1) return "invalid file header for svjson"
-	const htry = (...lst) => {
-		for (const a of lst) {
-			const j = header.indexOf(a)
-			if (j != -1) return j
-		}
-		return -1
-	}
-	let i = htry("sample")
-	if (i != -1) header[i] = "sample"
-	i = htry("sampletype")
-	if (i != -1) header[i] = "sampletype"
-	i = htry("patient")
-	if (i != -1) header[i] = "patient"
-	i = htry("json", "jsontext")
-	if (i == -1) return ["json missing from header"]
-	header[i] = "jsontext"
-	return [null, header]
-}
-
-export function parseline(i, line, flag, header) {
-	if (line == "" || line[0] == "#") return
-	const lst = line.split("\t")
-	const m = {}
-	const badlines = flag.svjson.badlines
-
-	for (let j = 0; j < header.length; j++) {
-		m[header[j]] = lst[j]
-	}
-	if (!m.jsontext) {
-		badlines.push([i, "missing jsontext", lst])
-		return
-	}
-	if (bulk.parsesample(m, flag, i, lst, badlines)) {
-		return
-	}
-	let json
-	try {
-		json = JSON.parse(m.jsontext)
-	} catch (e) {
-		badlines.push([i, "invalid JSON text", lst])
-		return
-	}
-	// duplicating logic in pediatric.js
-	if (Array.isArray(json)) {
-		// json is pairlst
-		for (const pair of json) {
-			if (pair.a && pair.a.name && pair.a.isoform) {
-				flag.good++
-				const m2 = {
-					dt: common.dtfusionrna,
-					class: common.mclassfusionrna,
-					isoform: pair.a.isoform,
-					mname: pair.b.name,
-				}
-				for (const k in m) {
-					if (k != "jsontext") m2[k] = m[k]
-				}
-				m2.pairlst = duplicate(json)
-				const n = pair.a.name.toUpperCase()
-				if (!flag.data[n]) {
-					flag.data[n] = []
-				}
-				flag.data[n].push(m2)
-			}
-			if (pair.b && pair.b.name && pair.b.isoform) {
-				flag.good++
-				const m2 = {
-					dt: common.dtfusionrna,
-					class: common.mclassfusionrna,
-					isoform: pair.b.isoform,
-					mname: pair.a.name,
-				}
-				for (const k in m) {
-					if (k != "jsontext") m2[k] = m[k]
-				}
-				m2.pairlst = duplicate(json)
-				const n = pair.b.name.toUpperCase()
-				if (!flag.data[n]) {
-					flag.data[n] = []
-				}
-				flag.data[n].push(m2)
-			}
-		}
-	} else {
-		json.dt = json.typecode
-		delete json.typecode
-		switch (json.dt) {
-			case common.dtitd:
-				json.class = common.mclassitd
-				json.mname = "ITD"
-				break
-			case common.dtnloss:
-				json.class = common.mclassnloss
-				json.mname = "N-loss"
-				break
-			case common.dtcloss:
-				json.class = common.mclasscloss
-				json.mname = "C-loss"
-				break
-			case common.dtdel:
-				json.class = common.mclassdel
-				json.mname = "Del"
-				break
-			case common.dtsv:
-				json.class = common.mclasssv
-				json.mname = "SV"
-				break
-			default:
-				badlines.push([i, "unknown datatype", lst])
-				return
-		}
-		// record only about a single gene
-		if (!json.gene) {
-			badlines.push([i, "json.gene missing", lst])
-			return
-		}
-		flag.good++
-		for (const k in m) {
-			if (k != "jsontext") {
-				json[k] = m[k]
-			}
-		}
-		const n = flag.geneToUpper
-			? json.gene.toUpperCase()
-			: json.gene.toUpperCase()
-		if (!flag.data[n]) {
-			flag.data[n] = []
-		}
-		flag.data[n].push(json)
-	}
-}
-
-function duplicate(lst) {
-	const d = []
-	for (const pair of lst) {
-		const p = { a: {}, b: {} }
-		for (const k in pair) {
-			if (k != "a" && k != "b") p[k] = pair[k]
-		}
-		for (const k in pair.a) {
-			p.a[k] = pair.a[k]
-		}
-		for (const k in pair.b) {
-			p.b[k] = pair.b[k]
-		}
-		d.push(p)
-	}
-	return d
-}

package/src/bulk.trunc.js

@@ -1,132 +0,0 @@
-////////////////////////////////////
-//
-//  shared between client and server
-//
-////////////////////////////////////
-
-import * as common from "./common.js"
-import * as bulk from "./bulk.js"
-
-export function parseheader(line, flag) {
-	const header = line.toLowerCase().split("\t")
-	if (header.length <= 1) return "invalid header line for truncation"
-	const htry = (...lst) => {
-		for (const e of lst) {
-			const j = header.indexOf(e)
-			if (j != -1) return j
-		}
-		return -1
-	}
-	let i = htry("gene")
-	if (i == -1) return "gene missing from header"
-	header[i] = "gene"
-	i = htry(
-		"annovar_isoform",
-		"mrna_accession",
-		"mrna accession",
-		"refseq_mrna_id",
-		"annovar_sj_filter_isoform",
-		"refseq",
-		"isoform"
-	)
-	if (i == -1) return "isoform missing from header"
-	header[i] = "isoform"
-	let hasrnapos = false
-	i = htry("rnaposition")
-	if (i != -1) {
-		header[i] = "rnaposition"
-		hasrnapos = true
-	}
-	i = htry("losstype")
-	if (i == -1) return "lossType missing from header"
-	header[i] = "losstype"
-	let hasgenomic = false
-	i = htry("chromosome", "chr")
-	if (i != -1) {
-		header[i] = "chr"
-		i = htry(
-			"start",
-			"start_position",
-			"wu_hg19_pos",
-			"chr_position",
-			"position"
-		)
-		if (i == -1) {
-			return "genomic position missing from header"
-		}
-		header[i] = "pos"
-		hasgenomic = true
-	}
-	if (!hasrnapos && !hasgenomic) {
-		return "neither rnaposition nor genomic position is given"
-	}
-
-	i = htry("sample", "sample_name", "tumor_sample_barcode")
-	if (i != -1) header[i] = "sample"
-	i = htry("patient", "donor", "target_case_id")
-	if (i != -1) header[i] = "patient"
-	i = htry("disease")
-	if (i != -1) header[i] = "disease"
-	i = htry("origin")
-	if (i != -1) header[i] = "origin"
-	i = htry("sampletype", "sample type", "sample_type")
-	if (i != -1) header[i] = "sampletype"
-	flag.truncation.header = header
-	flag.truncation.loaded = true
-	return false
-}
-
-export function parseline(i, line, flag) {
-	if (line == "" || line[0] == "#") return
-	const lst = line.split("\t")
-	const m = {}
-	for (let j = 0; j < flag.truncation.header.length; j++) {
-		m[flag.truncation.header[j]] = lst[j]
-	}
-	if (!m.gene) {
-		flag.truncation.badlines.push([i, "missing gene", lst])
-		return
-	}
-	if (m.rnaposition) {
-		const v = Number.parseInt(m.rnaposition)
-		if (Number.isNaN(v) || v < 0) {
-			flag.truncation.badlines.push([i, "invalid rnaPosition value", lst])
-			return
-		}
-		m.rnaposition = v
-	}
-	if (m.pos) {
-		const v = Number.parseInt(m.pos)
-		if (Number.isNaN(v) || v < 0) {
-			flag.truncation.badlines.push([i, "invalid genomic position", lst])
-			return
-		}
-		m.pos = v
-	}
-	if (!m.losstype) {
-		flag.truncation.badlines.push([i, "missing lossType value", lst])
-		return
-	}
-	if (m.losstype != "n" && m.losstype != "c") {
-		flag.truncation.badlines.push([i, 'lossType value not "n" or "c"', lst])
-		return
-	}
-	if (bulk.parsesample(m, flag, i, lst, flag.truncation.badlines)) {
-		return
-	}
-	if (m.losstype == "n") {
-		m.dt = common.dtnloss
-		m.class = common.mclassnloss
-		m.mname = "N-loss"
-	} else {
-		m.dt = common.dtcloss
-		m.class = common.mclasscloss
-		m.mname = "C-loss"
-	}
-	flag.good++
-	const n = flag.geneToUpper ? m.gene.toUpperCase() : m.gene
-	if (!(n in flag.data)) {
-		flag.data[n] = []
-	}
-	flag.data[n].push(m)
-}

package/src/clustering.js

@@ -1,66 +0,0 @@
-export const clusterMethodLst = [
-	{
-		label: "Average",
-		value: "average",
-		title: `Cluster by average value`,
-	},
-	{
-		label: `Complete`,
-		value: "complete",
-		title: `Use the complete clustering method`,
-	},
-	{
-		label: `Single`,
-		value: "single",
-		title: `Use the single clustering method`,
-	},
-	{
-		label: `Ward.D`,
-		value: "ward.D",
-		title: `Use the ward.D clustering method`,
-	},
-	{
-		label: `Ward.D2`,
-		value: "ward.D2",
-		title: `Use the ward.D2 clustering method`,
-	},
-	{
-		label: `Mcquitty`,
-		value: "mcquitty",
-		title: `Use the Mcquity clustering method`,
-	},
-	/* These methods are currently disabled because the dendrogram lines tend to cross one another.
-	{
-		label: `Centroid`,
-		value: 'centroid',
-		title: `Use the centroid clustering method`
-	},
-    	{
-		label: `Median`,
-		value: 'median',
-		title: `Use the median clustering method`
-	}
-        */
-]
-export const distanceMethodLst = [
-	{
-		label: "Euclidean",
-		value: "euclidean",
-		title: `Calculate distance using euclidean method`,
-	},
-	{
-		label: "Maximum",
-		value: "maximum",
-		title: `Maximum distance between two components of x and y`,
-	},
-	{
-		label: "Manhattan",
-		value: "manhattan",
-		title: `Calculate distance using the absolute distance between the two vectors`,
-	},
-	{
-		label: "Canberra",
-		value: "canberra",
-		title: `Calculate distance using Canberra method`,
-	},
-]