@sjcrh/proteinpaint-shared 2.187.0 → 2.188.1

package/src/compute.percentile.js

@@ -1,11 +0,0 @@
-// compute the percentile value from an array of values
-// sorted parameter allows to skip sorting if array is pre-sorted
-// source: https://www.dummies.com/article/academics-the-arts/math/statistics/how-to-calculate-percentiles-in-statistics-169783/
-export default function computePercentile(values, percentile, sorted = false) {
-	if (!sorted) values.sort((a, b) => a - b)
-	const index = Math.abs((percentile / 100) * values.length - 1)
-	const value = Number.isInteger(index)
-		? (values[index] + values[index + 1]) / 2
-		: values[Math.ceil(index)]
-	return value
-}

package/src/doc.js

@@ -1,6 +0,0 @@
-const test = {}
-function doc(opts) {
-	if (opts.type in test) throw `test['${opts.type}'] already exists`
-	test[opts.type] = opts.test
-}
-export { doc, test }

package/src/fetch-helpers.js

@@ -1,323 +0,0 @@
-import { hash } from "./hash.js"
-import { encode } from "./urljson.js"
-import { deepFreeze } from "./helpers.js"
-
-/*
-	ezFetch()
-	fetch wrapper with automatic response content-type detection and handling
-
-	- this addresses issues with ky.json() or got.json(), where a HTTP 404 NOT FOUND
-		response with text/html can break error handling/logging, making it harder to debug
-
-	- this also automatically handles multipart responses
-
-  - NOTE: for backend, use xfetch() instead, it uses ky() and its built-in retry support
-
-	arguments:
-	url
-	init{headers?, body?}
-	- first two arguments are same as native fetch
-*/
-export async function ezFetch(_url, init = {}, opts = {}) {
-	const url = opts.autoMethod ? mayAdjustRequest(_url, init) : _url
-	if (typeof init.body === "object") init.body = JSON.stringify(init.body)
-
-	return fetch(url, init).then(async (r) => {
-		const response = await processResponse(r)
-		if (!r.ok) {
-			console.log("ezFetch error " + r.status)
-			console.log(response)
-			throw response
-		}
-		return response
-	})
-}
-
-function mayAdjustRequest(url, init) {
-	const method = init.method?.toUpperCase() || "GET"
-	if (method == "POST") {
-		if (!init.headers) init.headers = {}
-		if (init.body) {
-			if (!init.headers["content-type"])
-				init.headers["content-type"] = "application/json"
-			if (init.headers["content-type"].toLowerCase() == "application/json") {
-				// if consumer code has pre-encoded the body, parse to verify correctness
-				if (typeof init.body == "string") init.body = JSON.parse(init.body)
-				init.body = JSON.stringify(init.body)
-			}
-		}
-		return url
-	}
-	// default to GET method per native fetch
-	if (init.body) {
-		if (typeof init.body != "object") throw `init.body should be an object`
-		// init.body should be an object, to be converted to GET URL search parameter strings
-		if (!url.includes("?")) url += "?"
-		return `${url}${encode(init.body)}`
-	}
-}
-
-/* 
-r: a native fetch response argument
-
-potentially allow "application/octet-stream" as response type
-in such case it will not try to parse it as json
-also the caller should just call dofetch2() without a serverData{}
-rather than dofetch3
-*/
-export async function processResponse(r) {
-	// if (!r.ok) {
-	//   throw new Error(`HTTP error! status: ${r.status}`)
-	// }
-	const ct = r.headers.get("content-type") // content type is always present
-	if (!ct) throw `missing response.header['content-type']`
-	if (ct.includes("/json")) {
-		const payload = await r.json()
-		// server should use a standard HTTP response status 400+, 500+
-		// so that !r.ok will already be caught when wrapping fetch with try-catch
-		// if (payload.error || payload.status == '') throw payload
-		// if (payload.status === 'error') throw payload.message || payload
-		return payload
-	}
-	if (ct.includes("/text") || ct.includes("text/")) {
-		return r.text()
-	}
-	if (ct.includes("multipart")) {
-		if (ct.startsWith("multipart/form-data")) return processFormData(r)
-		else throw `cannot handle response content-type: '${ct}'`
-	}
-	if (ct == "application/x-ndjson-nestedkey") {
-		return processNDJSON_nestedKey(r)
-	}
-	// call blob() as catch-all
-	// https://developer.mozilla.org/en-US/docs/Web/API/Response
-	return r.blob()
-}
-
-/*
-	expected response format
-	--boundary-text-from-HTTP-headers-content-type
-	header-key1: header-value1
-	header-key2: header-value2
-
-	...json, text, blob, value, etc...
-	--boundary-text-from-HTTP-headers-content-type
-	... same format as previous chunk ...
-
-	--boundary-text-from-HTTP-headers-content-type--
-*/
-
-export async function processFormData(res) {
-	const decoder = new TextDecoder()
-	const data = {}
-	try {
-		const form = await res.formData()
-		// The key of each form entry is a string, and the value is either a string or a Blob.
-		// see https://developer.mozilla.org/en-US/docs/Web/API/FormData/entries
-		for (const [key, value] of form.entries()) {
-			if (value.type) {
-				// value is a Blob
-				data[key] = { headers: { "content-type": value.type }, body: value }
-			} else {
-				// value is a string, assume to be application/x-jsonlines (one json encoded value per line)
-				// and convert into an array of json-decoded values
-				const body = !value ? [] : value.trim().split("\n").map(JSON.parse)
-				data[key] = { headers: { "content-type": "application/json" }, body }
-			}
-		}
-		return data
-	} catch (e) {
-		throw e
-	}
-}
-
-async function processNDJSON_nestedKey(r) {
-	// 1. Pipe through TextDecoder to convert bytes to text
-	const stream = r.body.pipeThrough(new TextDecoderStream())
-	const reader = stream.getReader()
-	let rootObj = {}
-
-	let buffer = ""
-
-	while (true) {
-		const { value, done } = await reader.read()
-		if (done) break
-
-		// 2. Add new chunk to buffer
-		buffer += value
-
-		// 3. Split by newline
-		let parts = buffer.split("\n")
-
-		// 4. Keep the last partial line in the buffer
-		buffer = parts.pop()
-
-		// 5. Process complete lines
-		for (const line of parts) {
-			if (line.trim()) {
-				const [keys, data] = JSON.parse(line) //; console.log(143, keys, data) // Process JSON data
-				if (!keys.length) rootObj = data
-				else {
-					const lastKey = keys.pop()
-					let target = rootObj
-					for (const k of keys) target = target[k]
-					target[lastKey] = data
-				}
-			}
-		}
-	}
-	return rootObj
-}
-
-// key: request object reference or computed string dataName
-// value: {
-//   response: fetch promise or response,
-//   exp: expiration timestamp
-// }
-const dataCache = new Map()
-// maximum number of cached dataNames, oldest will be deleted if this is exceeded
-const maxNumOfDataKeys = 10
-const cacheLifetime = 1000 * 60 * 5
-/*
-	memFetch()
-	- fetch wrapper that saves cached responses into memory and recovers them for matching subsequent requests
-	- recommended for caching responses in the backend, with the opts.q argument to cache per expressjs request object
-	- should call deleteCache(request) at the end of request handling, to free unneeded cache
-	
-	See the usage note for getDataName() to avoid non-unique request/response.
-	
-	Arguments:
-	url
-	init{headers?, body?}
-	- first two arguments are same as native fetch
-  - when passing opts.client, may include other applicable options inside the init{} object, such as retry
-
-	opts{client}
-
-  client: use this http client instead of native fetch
-    - since fetch-helpers is shared between server and frontend workspaces, 
-      cannot directly import non-native modules at the beginning of this code file 
-    - for server side usage, client may be `xfetch()`, `ky` or other libraries 
-*/
-export async function memFetch(url, init, opts = {}) {
-	if (typeof init.body === "object") init.body = JSON.stringify(init.body)
-	const dataKey = opts.q || (await getDataName(url, init))
-	const { response, exp } = dataCache.get(dataKey) || {}
-	const now = Date.now()
-	let result = response // either a Promise or actual data
-
-	if (result) {
-		// extend the expiration, since exp is more about managing the cache size
-		// and not the validity of the cached response. A response for the current
-		// dataName req.url + body + headers is technically valid until a new data version
-		// gets published.
-		dataCache.set(dataKey, { response, exp: now + cacheLifetime })
-		return result
-	} else {
-		try {
-			// IMPORTANT: do not await so that this same promise may be reused
-			// by subsequent requests with the same dataKey
-			result = opts.client
-				? opts
-						.client(url, init, Object.assign(opts, { client: undefined }))
-						.then((response) => {
-							// replace the cached promise result with the actual data,
-							// since persisting a cached promise for a long time is likely not best practice
-							dataCache.set(dataKey, {
-								response,
-								exp: Date.now() + cacheLifetime,
-							})
-							return response
-						})
-				: fetch(url, init)
-						.then(async (r) => {
-							const response = await processResponse(r)
-							if (!r.ok) {
-								console.trace(response)
-								throw (
-									"memFetch error " +
-									r.status +
-									": " +
-									(typeof response == "object"
-										? response.message || response.error
-										: response)
-								)
-							}
-							// replace the cached promise result with the actual data,
-							// since persisting a cached promise for a long time is likely not best practice
-							dataCache.set(dataKey, {
-								response: deepFreeze(response),
-								exp: Date.now() + cacheLifetime,
-							})
-							return response
-						})
-						.catch((e) => {
-							if (dataCache.get(dataKey)) dataCache.delete(dataKey)
-							throw e
-						})
-
-			dataCache.set(dataKey, {
-				response: result,
-				exp: Date.now() + cacheLifetime,
-			})
-			manageCacheSize(now)
-			return result
-		} catch (e) {
-			// delete this cache only if it is a promise;
-			// do not delete a valid resolved data cache
-			if (dataCache.get(dataKey) instanceof Promise) dataCache.delete(dataKey)
-			throw e
-		}
-	}
-}
-
-export function deleteCache(key) {
-	dataCache.delete(key)
-}
-
-export function manageCacheSize(_now) {
-	const now = _now || Date.now()
-	const keyExp = []
-	for (const [key, result] of dataCache.entries()) {
-		if (result.exp < now) dataCache.delete(key)
-		else keyExp.push({ key, exp: result.exp })
-	}
-	if (dataCache.size > maxNumOfDataKeys) {
-		const oldestEntries = keyExp
-			.sort((a, b) => a.exp - b.exp)
-			.slice(maxNumOfDataKeys)
-		for (const entry of oldestEntries) dataCache.delete(entry.key)
-	}
-}
-
-/*
-	NOTE: When used in client-side code, an HttpOnly cookie for a logged in user will not be
-	tracked in init.headers below. 
-*/
-export async function getDataName(url, init) {
-	// IMPORTANT: must ensure dataName is unique to either public or logged-in user
-	const dataName =
-		url +
-		" | " +
-		init.method +
-		" | " +
-		init.body +
-		" | " +
-		JSON.stringify(init.headers)
-	return await hash(dataName)
-}
-
-//
-export function clearMemFetchDataCache(opts = {}) {
-	if (!opts.serverData) {
-		dataCache.clear()
-		return
-	}
-	if (typeof opts.serverData != "object")
-		throw `opts.serverData is not an object`
-	for (const k of Object.keys(opts.serverData)) {
-		delete opts.serverData[k]
-	}
-	if (optsServerDataNames.has(opts.serverData))
-		optsServerDataNames.delete(opts.serverData)
-}

package/src/fileSize.js

@@ -1,6 +0,0 @@
-export function fileSize(v) {
-	if (v > 1e9) return (v / 1e9).toFixed(2) + " GB"
-	if (v > 1e6) return (v / 1e6).toFixed(2) + " MB"
-	if (v > 1e3) return (v / 1e3).toFixed(2) + " KB"
-	return v + " Bytes"
-}

package/src/filter.js

@@ -1,221 +0,0 @@
-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
-}
-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)
-}
-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
-}
-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
-}
-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/hash.js

@@ -1,21 +0,0 @@
-const encoder = new TextEncoder()
-
-export async function hash(message) {
-	const msgUint8 = encoder.encode(message) // encode as (utf-8) Uint8Array
-	const hashBuffer = await crypto.subtle.digest("SHA-1", msgUint8) // hash the message
-	const hashArray = Array.from(new Uint8Array(hashBuffer)) // convert buffer to byte array
-	const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("") // convert bytes to hex string
-	return hexToBase64(hashHex).replace("=", "-") // shorten from 40 to 28 chars
-}
-
-function hexToBase64(hexStr) {
-	return btoa(
-		[...hexStr].reduce(
-			(acc, _, i) =>
-				(acc += !((i - 1) & 1)
-					? String.fromCharCode(parseInt(hexStr.substring(i - 1, i + 1), 16))
-					: ""),
-			""
-		)
-	)
-}

package/src/helpers.js

@@ -1,88 +0,0 @@
-/*
-this is a helper file with a collection of functions to be used in backend and client side code. Here is a list.
-
-1. isNumeric(n)
-2. strictNumeric(n) 
-2. convertUnits
-3. TODO - move computepercentile, roundValue, etc here?
-*/
-
-// checks whether given argument n is Numeric, with option to cast from string
-export function isNumeric(n) {
-	const v = typeof n != "string" || n === "" ? n : Number(n)
-	const f = parseFloat(n)
-	return !isNaN(f) && Number.isFinite(v) && v === f
-}
-
-// like isNumeric but does not cast from string
-export function isStrictNumeric(n) {
-	return typeof n === "number" && Number.isFinite(n)
-}
-
-// converts a value from a unit to another unit
-export function convertUnits(v, fromUnit, toUnit, scaleFactor, compact) {
-	// do floor() on toUnit
-	// do ceil() on fromUnit, in case v is decimal (from violin range selection) and to keep showing integer fromUnit
-	if (scaleFactor >= 1) {
-		const toUnitV = Math.floor(v * scaleFactor)
-		if (compact) return `${toUnitV}${toUnit.charAt(0)}`
-		return `${toUnitV} ${toUnitV > 1 ? toUnit + "s" : ""}`
-	}
-	const toUnitV = Math.floor(v * scaleFactor)
-	const fromUnitV = Math.ceil(v % (1 / scaleFactor))
-
-	if (fromUnitV == 0) {
-		if (compact) return `${toUnitV}${toUnit.charAt(0)}`
-		return `${toUnitV} ${toUnitV > 1 ? toUnit + "s" : ""}`
-	}
-
-	if (compact)
-		return `${toUnitV}${toUnit.charAt(0)}${fromUnitV}${fromUnit.charAt(0)}`
-	return `${toUnitV} ${toUnitV > 1 ? toUnit + "s" : toUnit} ${fromUnitV} ${
-		fromUnitV > 1 ? fromUnit + "s" : fromUnit
-	}`
-}
-
-export function deepEqual(x, y) {
-	if (x === y) {
-		return true
-	} else if (
-		typeof x == "object" &&
-		x != null &&
-		typeof y == "object" &&
-		y != null
-	) {
-		if (Object.keys(x).length != Object.keys(y).length) {
-			return false
-		}
-
-		for (var prop in x) {
-			if (y.hasOwnProperty(prop)) {
-				if (!deepEqual(x[prop], y[prop])) return false
-			} else {
-				return false
-			}
-		}
-		return true
-	} else return false
-}
-
-export function deepFreeze(obj) {
-	Object.freeze(obj)
-	// not using for..in loop, in order to not descend into inherited props/methods
-	for (const value of Object.values(obj)) {
-		if (value !== null && typeof value == "object") deepFreeze(value)
-	}
-	return obj
-}
-
-export class CustomError extends Error {
-	level = "" // '' | 'warn'
-
-	constructor(message, opts = {}) {
-		super(message)
-		if (opts.name) this.name = opts.name
-		if (opts.code) this.code = opts.code
-		if (opts.level) this.level = opts.level
-	}
-}