@sjcrh/proteinpaint-shared 2.78.0-0

package/src/urljson.ts

@@ -0,0 +1,85 @@
+/*
+	A custom encoder-decoder for URL query parameter values
+
+	All values are strings except for the following, which
+	will are assumed to be json-encoded:
+
+	- those that correspond to JSON reserved keywords: true, false, null
+	- numeric values using the isNumeric() function below
+	- values that are wrapped by "", {}, []
+
+	In addition, a URL-payload that includes an `encoding=urljson` parameter
+	will cause all query parameter values to be processed by the decode()
+	function below. This is not required, but may help remove ambiguity, especially
+	to distinguish urljson-encoded params vs legacy URL params that have 
+	been manually coded in a way that doesn't conform to the expectations here.
+
+	Why not just encode every URL query parameter value as JSON?
+
+	- That makes the URL harder to read, since more encoding characters have to
+		be URI (percent) encoded. In contrast, since most values are strings or numbers,
+	  the encoder below leaves those values alone for better readability of the URL. For
+	  example, unambiguous strings would not have to be wrapped with double-quotes
+	  that are then URI encoded.
+
+	- The decoder will always accept and correctly process values that are JSON-encoded.
+	  So the encoding exceptions above do not prevent harder-to-read JSON-encoded string
+	  values. 
+*/
+
+// a URL query parameters object with values to be encoded
+export type UrlJsonRaw = {
+	[key: string]: any //boolean | string | number | any[] | null | undefined  //| { [key: string]: any }
+}
+
+// a URL query parameters object with values to be decoded
+export type UrlJsonEncoded = {
+	[key: string]: string
+}
+
+const reserved = ['false', 'true', 'null', 'undefined']
+const delimiters = ['"', '{', '[']
+
+export function encode(rawObject: UrlJsonRaw) {
+	const params: any[] = []
+	for (const [key, value] of Object.entries(rawObject)) {
+		if (typeof value == 'string' && !isNumeric(value) && !reserved.includes(value) && !delimiters.includes(value[0])) {
+			// no need to json-encode a string before percent encoding
+			// if it doesn't contain reserved JSON keywords/wrapper characters
+			params.push(`${key}=${encodeURIComponent(value)}`)
+		} else if (value !== undefined) {
+			params.push(`${key}=${encodeURIComponent(JSON.stringify(value))}`)
+		}
+	}
+	return params.join('&')
+}
+
+export function decode(query: UrlJsonEncoded) {
+	const encoding = query.encoding
+	for (const [key, value] of Object.entries(query)) {
+		//const value = query[key]
+		// if (value == 'undefined') {
+		// 	// maybe better to also detect this common error
+		// 	console.warn(`${key}="undefined" value as a string URL query parameter`)
+		// 	query[key] = undefined
+		// 	continue
+		// }
+		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
+			(value.startsWith('"') && value.endsWith('"')) ||
+			(value.startsWith('{') && value.endsWith('}')) ||
+			(value.startsWith('[') && value.endsWith(']'))
+		)
+			query[key] = JSON.parse(value)
+		// else the value is already a string
+	}
+	return query
+}
+
+function isNumeric(d) {
+	return !isNaN(parseFloat(d)) && isFinite(d) && d !== ''
+}

package/src/vcf.ann.js

@@ -0,0 +1,62 @@
+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
+}

package/src/vcf.csq.js

@@ -0,0 +1,153 @@
+import { vepinfo } from './common.js'
+/*
+parse csq field from a variant line, not header
+CSQ header must have already been parsed
+
+str: the csq value for a vcf line
+header: [ // something like this
+  { name: 'Allele' },
+  { name: 'Consequence' },
+  { name: 'IMPACT' },
+  { name: 'SYMBOL' },
+  { name: 'Gene' },
+  { name: 'Feature_type' },
+  { name: 'Feature' },
+  { name: 'BIOTYPE' },
+  { name: 'EXON' },
+  { name: 'INTRON' },
+  { name: 'HGVSc' },
+  { name: 'HGVSp' },
+  { name: 'cDNA_position' },
+  { name: 'CDS_position' },
+  { name: 'Protein_position' },
+  { name: 'Amino_acids' },
+  { name: 'Codons' },
+  { name: 'Existing_variation' },
+  { name: 'DISTANCE' },
+  { name: 'STRAND' },
+  { name: 'FLAGS' },
+  { name: 'SYMBOL_SOURCE' },
+  { name: 'HGNC_ID' },
+  { name: 'CANONICAL' },
+  { name: 'REFSEQ_MATCH' },
+  { name: 'GIVEN_REF' },
+  { name: 'USED_REF' },
+  { name: 'BAM_EDIT' },
+  { name: 'HGVS_OFFSET' },
+  { name: 'CLIN_SIG' },
+  { name: 'SOMATIC' },
+  { name: 'PHENO' }
+]
+
+m: {
+	mlst[ {} ]
+		.allele_original
+		.csq[ {} ] // parse_CSQ will add this array to this allele
+			._class
+			._csqrank
+			._dt
+			._gene
+			._isoform
+			._mname
+}
+
+*/
+
+export function parse_CSQ(str, header, m) {
+	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
+
+		//////////////////////////////////////
+		// NOTE
+		// mds2delete
+		// m.alleles[] is based on old vcf parsing and may delete?
+		// latest spec is m.mlst[]
+		//////////////////////////////////////
+
+		for (const a of m.mlst || m.alleles) {
+			if (a.allele_original == o.Allele) {
+				allele = a
+				break
+			}
+		}
+		if (!allele) {
+			if (o.Allele == '-') {
+				// deletion
+				if (m.mlst) {
+					if (m.mlst.length == 1) {
+						allele = m.mlst[0]
+					}
+				} else if (m.alleles) {
+					if (m.alleles.length == 1) {
+						allele = m.alleles[0]
+					}
+				}
+			} else {
+				for (const a of m.mlst || m.alleles) {
+					if (a.allele_original.substr(1) == o.Allele) {
+						// insertion, without first padding base
+						allele = a
+						break
+					}
+				}
+			}
+			if (!allele) {
+				// cannot match to allele!!!
+				continue
+			}
+		}
+		if (!allele.csq) {
+			allele.csq = []
+		}
+		allele.csq.push(o)
+
+		// gene
+		o._gene = o.SYMBOL || o.Gene
+
+		// isoform
+		if (o.Feature_type && o.Feature_type == 'Transcript') {
+			o._isoform = o.Feature.split('.')[0] // remove version
+		} else {
+			o._isoform = o._gene
+		}
+
+		// class
+		if (o.Consequence) {
+			const [dt, cls, rank] = vepinfo(o.Consequence)
+			o._dt = dt
+			o._class = cls
+			o._csqrank = rank
+		} else {
+			// FIXME
+			o._dt = dtsnvindel
+			o._class = mclassnonstandard
+		}
+		// mname
+		if (o.HGVSp) {
+			o._mname = decodeURIComponent(o.HGVSp.substr(o.HGVSp.indexOf(':') + 1))
+		} else if (o.Protein_position && o.Amino_acids) {
+			o._mname = decodeURIComponent(o.Protein_position + o.Amino_acids)
+		} else if (o.HGVSc) {
+			o._mname = o.HGVSc.substr(o.HGVSc.indexOf(':') + 1)
+		} else if (o.Existing_variation) {
+			o._name = o.Existing_variation
+		} else {
+		}
+	}
+	return true
+}

package/src/vcf.info.js

@@ -0,0 +1,50 @@
+/*
+to parse a variant line, not header
+
+cannot simply slice by /[;=]/, but read char by char
+case  CLNVI=Breast_Cancer_Information_Core__(BRCA2):745-4&base_change=C_to_G;
+case  k1=v1;DB;k2=v2;
+*/
+export function dissect_INFO(str) {
+	//let findequal=true
+	let findsemicolon = false
+	let findequalorsemicolon = true
+
+	let i = 0
+	let idx = 0
+
+	const k2v = {}
+	let lastkey
+
+	while (i < str.length) {
+		const c = str[i]
+		if (findequalorsemicolon) {
+			if (c == '=') {
+				findsemicolon = true
+				findequalorsemicolon = false
+				lastkey = str.substring(idx, i)
+				idx = i + 1
+			} else if (c == ';') {
+				// should be a flag
+				k2v[str.substring(idx, i)] = 1
+				idx = i + 1
+			}
+		} else if (findsemicolon && c == ';') {
+			findequalorsemicolon = true
+			findsemicolon = false
+			k2v[lastkey] = str.substring(idx, i)
+			lastkey = null
+			idx = i + 1
+		}
+		i++
+	}
+
+	const remainstr = str.substr(idx, i)
+	if (lastkey) {
+		k2v[lastkey] = remainstr
+	} else {
+		k2v[remainstr] = 1
+	}
+
+	return k2v
+}