@sjcrh/proteinpaint-shared 2.180.0 → 2.180.1

package/src/roundValue.js

@@ -25,7 +25,8 @@ export function roundValue(value, digits) {
 export function roundValueAuto(value, format = false, defaultDigits = 2) {
 	if (!value && value != 0) return value
 	const dp = decimalPlacesUntilFirstNonZero(value)
-	const digits = Math.abs(value) > 1 ? defaultDigits : dp > 0 ? dp + 1 : defaultDigits
+	const digits =
+		Math.abs(value) > 1 ? defaultDigits : dp > 0 ? dp + 1 : defaultDigits
 	if (format) return formatValue(value, digits)
 	return roundValue(value, digits)
 }
@@ -35,7 +36,7 @@ export function decimalPlacesUntilFirstNonZero(number) {
 	const numberStr = number.toString()
 
 	// Find the position of the decimal point
-	const decimalIndex = numberStr.indexOf('.')
+	const decimalIndex = numberStr.indexOf(".")
 
 	// If decimal point is not found or number is an integer, return 0
 	if (decimalIndex === -1 || decimalIndex === numberStr.length - 1) {
@@ -46,9 +47,9 @@ export function decimalPlacesUntilFirstNonZero(number) {
 	let decimalPlaces = 0
 	for (let i = decimalIndex + 1; i < numberStr.length; i++) {
 		// Increment the count of decimal places until a non-zero digit is found
-		if (numberStr[i] === '0') {
+		if (numberStr[i] === "0") {
 			decimalPlaces++
-		} else if (numberStr[i] >= '1' && numberStr[i] <= '9') {
+		} else if (numberStr[i] >= "1" && numberStr[i] <= "9") {
 			break
 		}
 	}

package/src/termdb.bins.js

@@ -1,88 +1,92 @@
-import { format } from 'd3-format'
-import { getColors } from './common.js'
-import { isNumeric, isStrictNumeric, convertUnits } from './helpers.js'
+import { format } from "d3-format"
+import { getColors } from "./common.js"
+import { isNumeric, isStrictNumeric, convertUnits } from "./helpers.js"
 
 export default function validate_bins(binconfig) {
 	// Number.isFinite('1') returns false, which is desired
 
 	const bc = binconfig
-	if (!bc || typeof bc !== 'object') throw 'bin schema must be an object'
+	if (!bc || typeof bc !== "object") throw "bin schema must be an object"
 	// assign default type
-	if (!('type' in bc)) bc.type = 'regular-bin'
+	if (!("type" in bc)) bc.type = "regular-bin"
 
-	if (bc.type == 'custom-bin') {
-		if (!Array.isArray(bc.lst)) throw 'binconfig.lst must be an array'
-		if (!bc.lst.length) throw 'binconfig.lst must have entries'
+	if (bc.type == "custom-bin") {
+		if (!Array.isArray(bc.lst)) throw "binconfig.lst must be an array"
+		if (!bc.lst.length) throw "binconfig.lst must have entries"
 		const first_bin = bc.lst[0]
 		const last_bin = bc.lst[bc.lst.length - 1]
 
 		for (const bin of bc.lst) {
-			if (!('startinclusive' in bin) && !('stopinclusive' in bin)) {
-				throw 'custom bin.startinclusive and/or bin.stopinclusive must be defined'
+			if (!("startinclusive" in bin) && !("stopinclusive" in bin)) {
+				throw "custom bin.startinclusive and/or bin.stopinclusive must be defined"
 			}
 
 			if (bin == first_bin) {
-				if ('startunbounded' in bin && !bin.startunbounded) {
+				if ("startunbounded" in bin && !bin.startunbounded) {
 					throw `a custom first bin must not set bin.startunbounded to false`
 				}
 				bin.startunbounded = true
-				if ('start' in bin) {
-					throw 'a custom first bin must not set a bin.start value'
+				if ("start" in bin) {
+					throw "a custom first bin must not set a bin.start value"
 				}
-				if ('start_percentile' in bin) {
-					throw 'the first bin must not set a bin.start_percentile value'
+				if ("start_percentile" in bin) {
+					throw "the first bin must not set a bin.start_percentile value"
 				}
-				if (!('stop' in bin)) {
+				if (!("stop" in bin)) {
 					throw `a custom first bin must define a bin.stop value`
 				}
 				if (!isStrictNumeric(bin.stop)) {
 					throw `a custom first bin.stop value should be numeric`
 				}
 			} else if (bin == last_bin) {
-				if (!('start' in bin)) {
+				if (!("start" in bin)) {
 					throw `a custom last bin must define a bin.start value`
 				}
 				if (!isStrictNumeric(bin.start)) {
 					throw `a custom last bin.start must be numeric`
 				}
-				if ('stopunbounded' in bin && !bin.stopunbounded) {
-					throw 'a custom last bin must not set bin.stopunbounded to false'
+				if ("stopunbounded" in bin && !bin.stopunbounded) {
+					throw "a custom last bin must not set bin.stopunbounded to false"
 				}
 				bin.stopunbounded = true
-				if ('stop' in bin) {
-					throw 'a custom last bin must not set a bin.stop value'
+				if ("stop" in bin) {
+					throw "a custom last bin must not set a bin.stop value"
 				}
 			} else {
 				if (bin.startunbounded || bin.stopunbounded) {
-					throw 'bin.startunbounded and bin.stopunbounded must not be set for non-first/non-last bins'
+					throw "bin.startunbounded and bin.stopunbounded must not be set for non-first/non-last bins"
 				}
-				if (!isStrictNumeric(bin.start)) throw 'bin.start must be numeric for a non-first bin'
-				if (!isStrictNumeric(bin.stop)) throw 'bin.stop must be numeric for a non-last bin'
+				if (!isStrictNumeric(bin.start))
+					throw "bin.start must be numeric for a non-first bin"
+				if (!isStrictNumeric(bin.stop))
+					throw "bin.stop must be numeric for a non-last bin"
 			}
 		}
-	} else if (bc.type == 'regular-bin') {
+	} else if (bc.type == "regular-bin") {
 		// required custom_bin parameter
-		if (!Number.isFinite(bc.bin_size)) throw 'non-numeric bin_size'
-		if (bc.bin_size <= 0) throw 'bin_size must be greater than 0'
+		if (!Number.isFinite(bc.bin_size)) throw "non-numeric bin_size"
+		if (bc.bin_size <= 0) throw "bin_size must be greater than 0"
 
 		if (!bc.startinclusive && !bc.stopinclusive) {
 			bc.startinclusive = 1
 			bc.stopinclusive = 0
 		}
 
-		if (!bc.first_bin) throw 'first_bin{} missing'
-		if (typeof bc.first_bin != 'object') throw 'first_bin{} is not an object'
-		if (!Object.keys(bc.first_bin).length) throw 'first_bin is an empty object'
+		if (!bc.first_bin) throw "first_bin{} missing"
+		if (typeof bc.first_bin != "object") throw "first_bin{} is not an object"
+		if (!Object.keys(bc.first_bin).length) throw "first_bin is an empty object"
 
 		{
 			const b = bc.first_bin
 			b.startunbounded = true
 			// requires stop_percentile, or stop
 			if (b.stop_percentile) {
-				if (!Number.isInteger(b.stop_percentile)) throw 'first_bin.stop_percentile should be integer'
-				if (b.stop_percentile <= 0 || b.stop_percentile >= 100) throw 'first_bin.stop_percentile out of bound (0-100)'
+				if (!Number.isInteger(b.stop_percentile))
+					throw "first_bin.stop_percentile should be integer"
+				if (b.stop_percentile <= 0 || b.stop_percentile >= 100)
+					throw "first_bin.stop_percentile out of bound (0-100)"
 			} else if (!Number.isFinite(b.stop)) {
-				throw 'first_bin.stop not a number when stop_percentile is not set'
+				throw "first_bin.stop not a number when stop_percentile is not set"
 			}
 		}
 
@@ -90,15 +94,17 @@ export default function validate_bins(binconfig) {
 			const b = bc.last_bin
 			// requires start_percentile or start
 			if (b.start_percentile) {
-				if (!Number.isInteger(b.start_percentile)) throw 'last_bin.start_percentile should be integer'
-				if (b.start_percentile <= 0 || b.start_percentile >= 100) throw 'last_bin.start_percentile out of bound (0-100)'
+				if (!Number.isInteger(b.start_percentile))
+					throw "last_bin.start_percentile should be integer"
+				if (b.start_percentile <= 0 || b.start_percentile >= 100)
+					throw "last_bin.start_percentile out of bound (0-100)"
 			} else if (!Number.isFinite(b.start)) {
-				throw 'last_bin.start not a number when start_percentile is not set'
+				throw "last_bin.start not a number when start_percentile is not set"
 			}
 
 			b.stopunbounded = true
-			if ('stop' in b) {
-				throw 'a regular last bin must not set a bin.stop value'
+			if ("stop" in b) {
+				throw "a regular last bin must not set a bin.stop value"
 			}
 		}
 	} else {
@@ -132,11 +138,13 @@ summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
 		const k2c = getColors(bc.lst.length) //to color bins
 		for (const bin of bc.lst) bin.color = k2c(bin.label)
 	}
-	if (bc.type == 'custom-bin') return JSON.parse(JSON.stringify(bc.lst))
-	if (typeof summaryfxn != 'function') throw 'summaryfxn required for modules/termdb.bins.js compute_bins()'
+	if (bc.type == "custom-bin") return JSON.parse(JSON.stringify(bc.lst))
+	if (typeof summaryfxn != "function")
+		throw "summaryfxn required for modules/termdb.bins.js compute_bins()"
 	const percentiles = target_percentiles(bc)
 	const summary = summaryfxn(percentiles)
-	if (!summary || typeof summary !== 'object') throw 'invalid returned value by summaryfxn'
+	if (!summary || typeof summary !== "object")
+		throw "invalid returned value by summaryfxn"
 	bc.results = { summary }
 	if (!bc.binLabelFormatter) bc.binLabelFormatter = getNumDecimalsFormatter(bc)
 
@@ -147,7 +155,7 @@ summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
 	const min = bc.first_bin.startunbounded
 		? minFloor
 		: bc.first_bin.start_percentile
-		? summary['p' + bc.first_bin.start_percentile]
+		? summary["p" + bc.first_bin.start_percentile]
 		: bc.first_bin.start
 	let max = maxCeil, // in order to include the max value in the last bin
 		last_start,
@@ -157,26 +165,27 @@ summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
 		max = bc.last_bin.stopunbounded
 			? maxCeil // in order to include the max value in the last bin
 			: bc.last_bin.stop_percentile
-			? summary['p' + bc.last_bin.stop_percentile]
+			? summary["p" + bc.last_bin.stop_percentile]
 			: isNumeric(bc.last_bin.stop) && bc.last_bin.stop <= summary.max // '0.0088' < 0.0088
 			? bc.last_bin.stop
 			: maxCeil // in order to include the max value in the last bin
 		last_start = isStrictNumeric(bc.last_bin.start_percentile)
-			? summary['p' + bc.last_bin.start_percentile]
+			? summary["p" + bc.last_bin.start_percentile]
 			: isStrictNumeric(bc.last_bin.start)
 			? bc.last_bin.start
 			: undefined
 		last_stop = bc.last_bin.stopunbounded
 			? null
 			: bc.last_bin.stop_percentile
-			? summary['p' + bc.last_bin.stop_percentile]
+			? summary["p" + bc.last_bin.stop_percentile]
 			: isStrictNumeric(bc.last_bin.stop)
 			? bc.last_bin.stop
 			: null
 	} else if (bc.lst) {
 		const last_bin = bc.lst[bc.lst.length - 1]
 		last_start = last_bin.start
-		last_stop = 'stop' in last_bin && !last_bin.stopunbounded ? last_bin.stop : maxCeil
+		last_stop =
+			"stop" in last_bin && !last_bin.stopunbounded ? last_bin.stop : maxCeil
 		max = last_stop
 	} else {
 		last_start = maxCeil
@@ -194,18 +203,23 @@ summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
 		startunbounded: bc.first_bin.startunbounded,
 		start: bc.first_bin.startunbounded ? undefined : min,
 		stop: isStrictNumeric(bc.first_bin.stop_percentile)
-			? +summary['p' + bc.first_bin.stop_percentile]
+			? +summary["p" + bc.first_bin.stop_percentile]
 			: isStrictNumeric(bc.first_bin.stop)
 			? +bc.first_bin.stop
 			: min + bc.bin_size,
 		startinclusive: bc.startinclusive,
-		stopinclusive: bc.stopinclusive
+		stopinclusive: bc.stopinclusive,
 	}
 
-	if (!isStrictNumeric(currBin.stop)) throw 'the computed first_bin.stop is non-numeric' + currBin.stop
+	if (!isStrictNumeric(currBin.stop))
+		throw "the computed first_bin.stop is non-numeric" + currBin.stop
 	const maxNumBins = 100 // harcoded limit for now to not stress sqlite
 
-	while ((numericMax && currBin.stop <= max) || (currBin.startunbounded && !bins.length) || currBin.stopunbounded) {
+	while (
+		(numericMax && currBin.stop <= max) ||
+		(currBin.startunbounded && !bins.length) ||
+		currBin.stopunbounded
+	) {
 		bins.push(currBin)
 		// force a computed last bin to have stopunbounded true
 		if (currBin.stop >= max) {
@@ -228,7 +242,7 @@ summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
 					? last_stop
 					: numericLastStart && upper > last_start && previousStop != last_start
 					? last_start
-					: upper
+					: upper,
 		}
 
 		if (currBin.stop >= max) {
@@ -240,12 +254,17 @@ summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
 			if (bc.last_bin && bc.last_bin.stopunbounded) currBin.stopunbounded = 1
 		}
 		if (currBin.start > currBin.stop) {
-			if (numericLastStart && currBin.stop == last_start && bc.last_bin && bc.last_bin.stopunbounded)
+			if (
+				numericLastStart &&
+				currBin.stop == last_start &&
+				bc.last_bin &&
+				bc.last_bin.stopunbounded
+			)
 				currBin.stopunbounded = true
 			else break
 		}
 		if (bins.length + 1 >= maxNumBins) {
-			bc.error = 'max_num_bins_reached'
+			bc.error = "max_num_bins_reached"
 			break
 		}
 	}
@@ -260,65 +279,97 @@ summaryfxn (percentiles)=> return {min, max, pX, pY, ...}
 
 function getNumDecimalsFormatter(bc) {
 	//return format('rounding' in bc ? bc.rounding : '')
-	return 'rounding' in bc ? format(bc.rounding) : d => d // default to labeling using the start/stop value as-is
+	return "rounding" in bc ? format(bc.rounding) : (d) => d // default to labeling using the start/stop value as-is
 }
 
 export function get_bin_label(bin, binconfig, valueConversion) {
 	/*
   Generate a numeric bin label given a bin configuration and an optional term valueConversion object
 */
-	if (!bin) return 'missing bin.label'
+	if (!bin) return "missing bin.label"
 	if (bin.label) return bin.label
 
 	const bc = binconfig
 	if (!bc.binLabelFormatter) bc.binLabelFormatter = getNumDecimalsFormatter(bc)
-	if (!bin.startunbounded && !bin.stopunbounded && !('startinclusive' in bin) && !('stopinclusive' in bin)) {
+	if (
+		!bin.startunbounded &&
+		!bin.stopunbounded &&
+		!("startinclusive" in bin) &&
+		!("stopinclusive" in bin)
+	) {
 		if (bc.startinclusive) bin.startinclusive = true
 		else if (bc.stopinclusive) bin.stopinclusive = true
 	}
 
-	const start = bc.use_as == 'bins' || bin.start
-	const stop = bc.use_as == 'bins' || bin.stop
+	const start = bc.use_as == "bins" || bin.start
+	const stop = bc.use_as == "bins" || bin.stop
 
 	let label_offset = 0
-	if ('label_offset' in bc) {
-		bc.label_offset_ignored = 'bin_size' in bc && bc.bin_size < bc.label_offset
+	if ("label_offset" in bc) {
+		bc.label_offset_ignored = "bin_size" in bc && bc.bin_size < bc.label_offset
 		if (!bc.label_offset_ignored) label_offset = bc.label_offset
-	} else if (bc.bin_size === 1 && bc.termtype == 'integer') {
+	} else if (bc.bin_size === 1 && bc.termtype == "integer") {
 		label_offset = 1
 	}
 
 	// one side-unbounded bins
 	// label will be ">v" or "<v"
 	if (bin.startunbounded) {
-		const oper = bin.stopinclusive ? '≤' : '<' // \u2264
+		const oper = bin.stopinclusive ? "≤" : "<" // \u2264
 		const v1 = valueConversion
-			? convertUnits(stop, valueConversion.fromUnit, valueConversion.toUnit, valueConversion.scaleFactor, true)
+			? convertUnits(
+					stop,
+					valueConversion.fromUnit,
+					valueConversion.toUnit,
+					valueConversion.scaleFactor,
+					true
+			  )
 			: bc.binLabelFormatter(stop) //bin.startinclusive && label_offset ? stop - label_offset : stop)
 		return oper + v1
 	}
 	// a data value may coincide with the last bin's start
 	if (bin.stopunbounded || start === stop) {
-		const oper = bin.startinclusive /*|| label_offset*/ ? '≥' : '>' // \u2265
+		const oper = bin.startinclusive /*|| label_offset*/ ? "≥" : ">" // \u2265
 		const v0 = valueConversion
-			? convertUnits(start, valueConversion.fromUnit, valueConversion.toUnit, valueConversion.scaleFactor, true)
+			? convertUnits(
+					start,
+					valueConversion.fromUnit,
+					valueConversion.toUnit,
+					valueConversion.scaleFactor,
+					true
+			  )
 			: bc.binLabelFormatter(start) //bin.startinclusive || start == min ? start : start + label_offset)
 		return oper + v0
 	}
 
 	// two-sided bins
 	if (label_offset && bin.startinclusive && !bin.stopinclusive) {
-		if (Number.isInteger(bc.bin_size) && Math.abs(start - stop) === label_offset) {
+		if (
+			Number.isInteger(bc.bin_size) &&
+			Math.abs(start - stop) === label_offset
+		) {
 			// make a simpler label when the range simply spans the bin_size
 			return (
-				'' +
+				"" +
 				(valueConversion
-					? convertUnits(start, valueConversion.fromUnit, valueConversion.toUnit, valueConversion.scaleFactor, true)
+					? convertUnits(
+							start,
+							valueConversion.fromUnit,
+							valueConversion.toUnit,
+							valueConversion.scaleFactor,
+							true
+					  )
 					: bc.binLabelFormatter(start))
 			)
 		} else {
 			const v0 = valueConversion
-				? convertUnits(start, valueConversion.fromUnit, valueConversion.toUnit, valueConversion.scaleFactor, true)
+				? convertUnits(
+						start,
+						valueConversion.fromUnit,
+						valueConversion.toUnit,
+						valueConversion.scaleFactor,
+						true
+				  )
 				: bc.binLabelFormatter(start)
 			const v1 = valueConversion
 				? convertUnits(
@@ -330,28 +381,40 @@ export function get_bin_label(bin, binconfig, valueConversion) {
 				  )
 				: bc.binLabelFormatter(stop - label_offset)
 			// ensure that last two bin labels make sense (the last is stopunbounded)
-			return +v0 >= +v1 ? v0.toString() : v0 + ' to ' + v1
+			return +v0 >= +v1 ? v0.toString() : v0 + " to " + v1
 		}
 	} else {
 		// stop_inclusive || label_offset == 0
-		const oper0 = bin.startinclusive ? '' : '>'
-		const oper1 = bin.stopinclusive ? '' : '<'
+		const oper0 = bin.startinclusive ? "" : ">"
+		const oper1 = bin.stopinclusive ? "" : "<"
 		const v0 = valueConversion
-			? convertUnits(start, valueConversion.fromUnit, valueConversion.toUnit, valueConversion.scaleFactor, true)
+			? convertUnits(
+					start,
+					valueConversion.fromUnit,
+					valueConversion.toUnit,
+					valueConversion.scaleFactor,
+					true
+			  )
 			: Number.isInteger(start)
 			? start
 			: bc.binLabelFormatter(start)
 		const v1 = valueConversion
-			? convertUnits(stop, valueConversion.fromUnit, valueConversion.toUnit, valueConversion.scaleFactor, true)
+			? convertUnits(
+					stop,
+					valueConversion.fromUnit,
+					valueConversion.toUnit,
+					valueConversion.scaleFactor,
+					true
+			  )
 			: Number.isInteger(stop)
 			? stop
 			: bc.binLabelFormatter(stop)
 		// after rounding the bin labels, the bin start may equal the last bin stop as derived from actual data
 		if (+v0 >= +v1) {
-			const oper = bin.startinclusive ? '≥' : '>' // \u2265
+			const oper = bin.startinclusive ? "≥" : ">" // \u2265
 			return oper + v0
 		} else {
-			return oper0 + v0 + ' to ' + oper1 + v1
+			return oper0 + v0 + " to " + oper1 + v1
 		}
 	}
 }
@@ -362,17 +425,17 @@ export function get_bin_range_equation(bin, binconfig) {
 	let range_eq
 	// should always use computed (not user-customized) bin label to determine bin range text
 	const copy = structuredClone(bin)
-	copy.label = '' // mutate only the copy, and not the original bin argument
+	copy.label = "" // mutate only the copy, and not the original bin argument
 	const bin_label = get_bin_label(copy, binconfig)
 	if (bin.startunbounded || bin.stopunbounded) {
 		// first or last bins, e.g. x ≤ 14 and x > 16
-		range_eq = x + ' ' + bin_label
+		range_eq = x + " " + bin_label
 	} else if (bin.startinclusive) {
 		// bins with startinclusive, e.g. 14 ≤ x < 16
-		range_eq = bin_label.replace('to <', '≤ ' + x + ' <')
+		range_eq = bin_label.replace("to <", "≤ " + x + " <")
 	} else if (bin.stopinclusive) {
 		// bins with stopinclusive, e.g. 14 < x ≤ 16
-		range_eq = bin_label.replace('>', '').replace('to', '< ' + x + ' ≤')
+		range_eq = bin_label.replace(">", "").replace("to", "< " + x + " ≤")
 	}
 	return range_eq
 }
@@ -380,10 +443,14 @@ export function get_bin_range_equation(bin, binconfig) {
 export function target_percentiles(binconfig) {
 	const percentiles = []
 	const f = binconfig.first_bin
-	if (f && isStrictNumeric(f.start_percentile)) percentiles.push(f.start_percentile)
-	if (f && isStrictNumeric(f.stop_percentile)) percentiles.push(f.stop_percentile)
+	if (f && isStrictNumeric(f.start_percentile))
+		percentiles.push(f.start_percentile)
+	if (f && isStrictNumeric(f.stop_percentile))
+		percentiles.push(f.stop_percentile)
 	const l = binconfig.last_bin
-	if (l && isStrictNumeric(l.start_percentile)) percentiles.push(l.start_percentile)
-	if (l && isStrictNumeric(l.stop_percentile)) percentiles.push(l.stop_percentile)
+	if (l && isStrictNumeric(l.start_percentile))
+		percentiles.push(l.start_percentile)
+	if (l && isStrictNumeric(l.stop_percentile))
+		percentiles.push(l.stop_percentile)
 	return percentiles
 }

package/src/termdb.initbinconfig.js

@@ -7,8 +7,15 @@ Initialize a bin configuration for a numeric dataset
 */
 export default function initBinConfig(data, opts = {}) {
 	if (!data.length)
-		return { mode: 'discrete', type: 'regular-bin', startinclusive: true, bin_size: null, first_bin: { stop: null } }
-	if (data.find(d => !Number.isFinite(d))) throw new Error('non-numeric values found')
+		return {
+			mode: "discrete",
+			type: "regular-bin",
+			startinclusive: true,
+			bin_size: null,
+			first_bin: { stop: null },
+		}
+	if (data.find((d) => !Number.isFinite(d)))
+		throw new Error("non-numeric values found")
 
 	let binConfig
 	const s = new Set(data)
@@ -21,12 +28,28 @@ export default function initBinConfig(data, opts = {}) {
 		// all data values will fall into the second bin
 		const value = [...s][0]
 		binConfig = {
-			type: 'custom-bin',
+			type: "custom-bin",
 			lst: [
-				{ stop: value, stopinclusive: false, startunbounded: true, label: '<' + value },
-				{ start: value, stop: value, startinclusive: true, stopinclusive: true, label: '=' + value },
-				{ start: value, startinclusive: false, stopunbounded: true, label: '>' + value }
-			]
+				{
+					stop: value,
+					stopinclusive: false,
+					startunbounded: true,
+					label: "<" + value,
+				},
+				{
+					start: value,
+					stop: value,
+					startinclusive: true,
+					stopinclusive: true,
+					label: "=" + value,
+				},
+				{
+					start: value,
+					startinclusive: false,
+					stopunbounded: true,
+					label: ">" + value,
+				},
+			],
 		}
 	} else {
 		// multiple unique values in data array
@@ -47,22 +70,23 @@ export default function initBinConfig(data, opts = {}) {
 		// first bin stop will equal either (minimum + bin size) or (5th percentile), whichever is larger.
 		const firstBinStop = Math.max(min + binSize, p5)
 		// round the bin values
-		let [binSize_rnd, firstBinStop_rnd, lastBinStart_rnd, rounding] = roundBinVals(binSize, firstBinStop, max, min)
+		let [binSize_rnd, firstBinStop_rnd, lastBinStart_rnd, rounding] =
+			roundBinVals(binSize, firstBinStop, max, min)
 		// generate the bin configuration
 		binConfig = {
-			type: 'regular-bin',
+			type: "regular-bin",
 			startinclusive: true,
 			bin_size: binSize_rnd,
-			first_bin: { stop: firstBinStop_rnd }
+			first_bin: { stop: firstBinStop_rnd },
 		}
 		if (lastBinStart_rnd) binConfig.last_bin = { start: lastBinStart_rnd }
 		if (rounding) binConfig.rounding = rounding
 	}
-	if ('format' in opts) {
-		if (opts.format === 'string') {
+	if ("format" in opts) {
+		if (opts.format === "string") {
 			return JSON.stringify(binConfig)
 		} else {
-			throw 'options are not in the correct format'
+			throw "options are not in the correct format"
 		}
 	} else {
 		return binConfig
@@ -75,14 +99,17 @@ function roundBinVals(binSize, firstBinStop, max, min) {
 	if (binSize >= 0.1 && binSize <= 2) {
 		// Round to the nearest one for small bin sizes
 		binSize_rnd = Math.round(binSize / (1 * 10 ** log)) * (1 * 10 ** log)
-		firstBinStop_rnd = Math.round(firstBinStop / (1 * 10 ** log)) * (1 * 10 ** log)
+		firstBinStop_rnd =
+			Math.round(firstBinStop / (1 * 10 ** log)) * (1 * 10 ** log)
 	} else {
 		// Round to the nearest five for large bin sizes
 		binSize_rnd = Math.round(binSize / (5 * 10 ** log)) * (5 * 10 ** log)
-		firstBinStop_rnd = Math.round(firstBinStop / (5 * 10 ** log)) * (5 * 10 ** log)
+		firstBinStop_rnd =
+			Math.round(firstBinStop / (5 * 10 ** log)) * (5 * 10 ** log)
 		if (binSize_rnd === 0) binSize_rnd = 1 * 10 ** log
 		if (firstBinStop_rnd === 0) firstBinStop_rnd = 1 * 10 ** log
-		if (binSize_rnd === 5 * 10 ** log && firstBinStop_rnd === 1 * 10 ** log) firstBinStop_rnd = 5 * 10 ** log
+		if (binSize_rnd === 5 * 10 ** log && firstBinStop_rnd === 1 * 10 ** log)
+			firstBinStop_rnd = 5 * 10 ** log
 	}
 	if (firstBinStop_rnd < min) firstBinStop_rnd = firstBinStop_rnd * 2
 	// if the number of bins is above 8 after rounding, then set the last bin start to restrict the number of bins to 8
@@ -94,8 +121,9 @@ function roundBinVals(binSize, firstBinStop, max, min) {
 		const digits = Math.abs(log)
 		binSize_rnd = Number(binSize_rnd.toFixed(digits))
 		firstBinStop_rnd = Number(firstBinStop_rnd.toFixed(digits))
-		if (lastBinStart_rnd) lastBinStart_rnd = Number(lastBinStart_rnd.toFixed(digits))
-		rounding = '.' + digits + 'f'
+		if (lastBinStart_rnd)
+			lastBinStart_rnd = Number(lastBinStart_rnd.toFixed(digits))
+		rounding = "." + digits + "f"
 	}
 	if (Object.is(firstBinStop_rnd, -0)) firstBinStop_rnd = 0
 	return [binSize_rnd, firstBinStop_rnd, lastBinStart_rnd, rounding]