uplot-webgpu 0.1.0

package/scripts/utils/opts.js

@@ -0,0 +1,844 @@
+import {
+	FEAT_TIME,
+} from './feats.js';
+
+import {
+	assign,
+
+	abs,
+	min,
+	max,
+
+	inf,
+	pow,
+	log2,
+	log10,
+	genIncrs,
+	round,
+	incrRoundUp,
+	roundDec,
+	floor,
+	fmtNum,
+	fixedDec,
+
+	retArg1,
+	noop,
+	ceil,
+	closestIdx,
+} from './utils.js';
+
+import {
+	hexBlack,
+	WIDTH,
+	HEIGHT,
+	LEGEND_DISP,
+} from './strings.js';
+
+import {
+	placeDiv,
+	setStylePx,
+} from './dom.js';
+
+import { DateZoned, fmtDate, floorSOP, PERIOD_DAY, PERIOD_MONTH, PERIOD_YEAR } from './fmtDate.js';
+
+//export const series = [];
+
+// default formatters:
+
+const onlyWhole = v => v % 1 == 0;
+
+const allMults = [1,2,2.5,5];
+
+// ...0.01, 0.02, 0.025, 0.05, 0.1, 0.2, 0.25, 0.5
+export const decIncrs = genIncrs(10, -32, 0, allMults);
+
+// 1, 2, 2.5, 5, 10, 20, 25, 50...
+export const oneIncrs = genIncrs(10, 0, 32, allMults);
+
+// 1, 2,      5, 10, 20, 25, 50...
+export const wholeIncrs = oneIncrs.filter(onlyWhole);
+
+export const numIncrs = decIncrs.concat(oneIncrs);
+
+const NL = "\n";
+
+const yyyy    = "{YYYY}";
+const NLyyyy  = NL + yyyy;
+const md      = "{M}/{D}";
+const NLmd    = NL + md;
+const NLmdyy  = NLmd + "/{YY}";
+
+const aa      = "{aa}";
+const hmm     = "{h}:{mm}";
+const hmmaa   = hmm + aa;
+const NLhmmaa = NL + hmmaa;
+const ss      = ":{ss}";
+
+const _ = null;
+
+function genTimeStuffs(ms) {
+	let	s  = ms * 1e3,
+		m  = s  * 60,
+		h  = m  * 60,
+		d  = h  * 24,
+		mo = d  * 30,
+		y  = d  * 365;
+
+	// min of 1e-3 prevents setting a temporal x ticks too small since Date objects cannot advance ticks smaller than 1ms
+	let subSecIncrs = ms == 1 ? genIncrs(10, 0, 3, allMults).filter(onlyWhole) : genIncrs(10, -3, 0, allMults);
+
+	let timeIncrs = subSecIncrs.concat([
+		// minute divisors (# of secs)
+		s,
+		s * 5,
+		s * 10,
+		s * 15,
+		s * 30,
+		// hour divisors (# of mins)
+		m,
+		m * 5,
+		m * 10,
+		m * 15,
+		m * 30,
+		// day divisors (# of hrs)
+		h,
+		h * 2,
+		h * 3,
+		h * 4,
+		h * 6,
+		h * 8,
+		h * 12,
+		// month divisors TODO: need more?
+		d,
+		d * 2,
+		d * 3,
+		d * 4,
+		d * 5,
+		d * 6,
+		d * 7,
+		d * 8,
+		d * 9,
+		d * 10,
+		d * 15,
+		// year divisors (# months, approx)
+		mo,
+		mo * 2,
+		mo * 3,
+		mo * 4,
+		mo * 6,
+		// century divisors
+		y,
+		y * 2,
+		y * 5,
+		y * 10,
+		y * 25,
+		y * 50,
+		y * 100,
+	]);
+
+	// [0]:   minimum num secs in the tick incr
+	// [1]:   default tick format
+	// [2-7]: rollover tick formats
+	// [8]:   mode: 0: replace [1] -> [2-7], 1: concat [1] + [2-7]
+	const _timeAxisStamps = [
+	//   tick incr    default          year                    month   day                   hour    min       sec   mode
+		[y,           yyyy,            _,                      _,      _,                    _,      _,        _,       1],
+		[d * 28,      "{MMM}",         NLyyyy,                 _,      _,                    _,      _,        _,       1],
+		[d,           md,              NLyyyy,                 _,      _,                    _,      _,        _,       1],
+		[h,           "{h}" + aa,      NLmdyy,                 _,      NLmd,                 _,      _,        _,       1],
+		[m,           hmmaa,           NLmdyy,                 _,      NLmd,                 _,      _,        _,       1],
+		[s,           ss,              NLmdyy + " " + hmmaa,   _,      NLmd + " " + hmmaa,   _,      NLhmmaa,  _,       1],
+		[ms,          ss + ".{fff}",   NLmdyy + " " + hmmaa,   _,      NLmd + " " + hmmaa,   _,      NLhmmaa,  _,       1],
+	];
+
+	// the ensures that axis ticks, values & grid are aligned to logical temporal breakpoints and not an arbitrary timestamp
+	// https://www.timeanddate.com/time/dst/
+	// https://www.timeanddate.com/time/dst/2019.html
+	// https://www.epochconverter.com/timezones
+	function timeAxisSplits(tzDate) {
+		return (self, axisIdx, scaleMin, scaleMax, foundIncr, foundSpace) => {
+			let splits = [];
+			let isYr = foundIncr >= y;
+			let isMo = foundIncr >= mo && foundIncr < y;
+			let isDays = foundIncr >= d && foundIncr < mo;
+			let isHours = foundIncr > h && foundIncr < d
+
+			// get the timezone-adjusted date
+			let minDate = tzDate(scaleMin);
+			let minDateTs = roundDec(minDate * ms, 3);
+
+			// get ts of 12am (this lands us at or before the original scaleMin)
+			let minMin = floorSOP(minDate, isYr || isMo ? PERIOD_YEAR : isDays ? PERIOD_MONTH : PERIOD_DAY); // should we do PERIOD_HOUR?
+			let minMinTs = roundDec(minMin * ms, 3);
+
+			if (isDays) {
+				let incrDays = foundIncr / d;
+
+				// incrs to add to month baseline
+				let skip = floor((minDate.getDate() - 1) / incrDays);
+				let split = minMinTs + (foundIncr * skip);
+
+				do {
+					let date = tzDate(split);
+					// adjust for DST misses
+					let hour = date.getHours();
+					if (hour != 0) {
+						split += hour > 12 ? h : -h;
+						date = tzDate(split);
+					}
+
+					// rolled over into next month onto non-divisible incr, reset baseline
+					if ((date.getDate() - 1) % incrDays > 0) {
+						date = floorSOP(date, PERIOD_MONTH);
+						split = date.getTime() * ms;
+
+						// make sure we're not rendering a collision between 31 and 1
+						if (split - splits[splits.length - 1] < foundIncr * 0.7)
+							splits.pop();
+					}
+
+					if (split > scaleMax)
+						break;
+
+					if (split >= scaleMin)
+						splits.push(split);
+
+					split += foundIncr;
+				} while (1);
+			}
+			else if (isMo || isYr) {
+				let subIncrs = 1;
+				let subIncrDays = 1;
+				let periodType = 0;
+				let periodMin = 0;
+
+				if (isMo) {
+					subIncrs = foundIncr / mo;
+					subIncrDays = 32;
+					periodType = PERIOD_MONTH;
+					periodMin = minDate.getMonth();
+				}
+				else if (isYr) {
+					subIncrs = foundIncr / y;
+					subIncrDays = 366;
+					periodType = PERIOD_YEAR;
+					periodMin = minDate.getYear();
+				}
+
+				foundIncr = subIncrs * subIncrDays * d;
+
+				let skip = floor(periodMin / subIncrDays);
+				let split = minMinTs + (foundIncr * skip);
+
+				do {
+					let date = floorSOP(tzDate(split), periodType);
+					split = date.getTime() * ms;
+
+					if (split > scaleMax)
+						break;
+
+					if (split >= scaleMin)
+						splits.push(split);
+
+					split += foundIncr;
+				} while (1);
+			}
+			else if (isHours) {
+				let incrHours = foundIncr / h;
+
+				let skip = floor(minDate.getHours() / incrHours);
+				let split = minMinTs + (foundIncr * skip);
+
+				do {
+					let date = tzDate(split);
+
+					// adjust for DST misses
+					let hour = date.getHours();
+					if (hour % incrHours > 0) {
+						let hour2 = tzDate(split - h).getHours();
+						split += hour2 % incrHours == 0 ? -h : h;
+					}
+
+					if (split > scaleMax)
+						break;
+
+					if (split >= scaleMin)
+						splits.push(split);
+
+					split += foundIncr;
+				} while (1);
+			}
+			else {
+				let split = minMinTs + incrRoundUp(minDateTs - minMinTs, foundIncr);
+
+				do {
+					if (split > scaleMax)
+						break;
+
+					if (split >= scaleMin)
+						splits.push(split);
+
+					split += foundIncr;
+				} while (1);
+			}
+
+			return splits;
+		}
+	}
+
+	return [
+		timeIncrs,
+		_timeAxisStamps,
+		timeAxisSplits,
+	];
+}
+
+export const [ timeIncrsMs, _timeAxisStampsMs, timeAxisSplitsMs ] = FEAT_TIME && genTimeStuffs(1);
+export const [ timeIncrsS,  _timeAxisStampsS,  timeAxisSplitsS  ] = FEAT_TIME && genTimeStuffs(1e-3);
+
+// base 2
+const binIncrs = genIncrs(2, -53, 53, [1]);
+
+/*
+console.log({
+	decIncrs,
+	oneIncrs,
+	wholeIncrs,
+	numIncrs,
+	timeIncrs,
+	fixedDec,
+});
+*/
+
+export function timeAxisStamps(stampCfg, fmtDate) {
+	return stampCfg.map(s => s.map((v, i) =>
+		i == 0 || i == 8 || v == null ? v : fmtDate(i == 1 || s[8] == 0 ? v : s[1] + v)
+	));
+}
+
+// TODO: will need to accept spaces[] and pull incr into the loop when grid will be non-uniform, eg for log scales.
+// currently we ignore this for months since they're *nearly* uniform and the added complexity is not worth it
+export function timeAxisVals(tzDate, stamps) {
+	return (self, splits, axisIdx, foundSpace, foundIncr) => {
+		let s = stamps.find(s => foundIncr >= s[0]) || stamps[stamps.length - 1];
+
+		// these track boundaries when a full label is needed again
+		let prevYear;
+		let prevMnth;
+		let prevDate;
+		let prevHour;
+		let prevMins;
+		let prevSecs;
+
+		return splits.map(split => {
+			let date = tzDate(split);
+
+			let newYear = date.getFullYear();
+			let newMnth = date.getMonth();
+			let newDate = date.getDate();
+			let newHour = date.getHours();
+			let newMins = date.getMinutes();
+			let newSecs = date.getSeconds();
+
+			let stamp = (
+				newYear != prevYear && s[2] ||
+				newMnth != prevMnth && s[3] ||
+				newDate != prevDate && s[4] ||
+				newHour != prevHour && s[5] ||
+				newMins != prevMins && s[6] ||
+				newSecs != prevSecs && s[7] ||
+				                       s[1]
+			);
+
+			prevYear = newYear;
+			prevMnth = newMnth;
+			prevDate = newDate;
+			prevHour = newHour;
+			prevMins = newMins;
+			prevSecs = newSecs;
+
+			return stamp(date);
+		});
+	}
+}
+
+// for when axis.values is defined as a static fmtDate template string
+export function timeAxisVal(tzDate, dateTpl) {
+	let stamp = fmtDate(dateTpl);
+	return (self, splits, axisIdx, foundSpace, foundIncr) => splits.map(split => stamp(tzDate(split)));
+}
+
+function mkDate(y, m, d) {
+	return new Date(y, m, d);
+}
+
+export function timeSeriesStamp(stampCfg, fmtDate) {
+	return fmtDate(stampCfg);
+};
+
+export const _timeSeriesStamp = '{YYYY}-{MM}-{DD} {h}:{mm}{aa}';
+
+export function timeSeriesVal(tzDate, stamp) {
+	return (self, val, seriesIdx, dataIdx) => dataIdx == null ? LEGEND_DISP : stamp(tzDate(val));
+}
+
+export function legendStroke(self, seriesIdx) {
+	let s = self.series[seriesIdx];
+	return s.width ? s.stroke(self, seriesIdx) : s.points.width ? s.points.stroke(self, seriesIdx) : null;
+}
+
+export function legendFill(self, seriesIdx) {
+	return self.series[seriesIdx].fill(self, seriesIdx);
+}
+
+export const legendOpts = {
+	show: true,
+	live: true,
+	isolate: false,
+	mount: noop,
+	markers: {
+		show: true,
+		width: 2,
+		stroke: legendStroke,
+		fill: legendFill,
+		dash: "solid",
+	},
+	idx: null,
+	idxs: null,
+	values: [],
+};
+
+function cursorPointShow(self, si) {
+	let o = self.cursor.points;
+
+	let pt = placeDiv();
+
+	let size = o.size(self, si);
+	setStylePx(pt, WIDTH, size);
+	setStylePx(pt, HEIGHT, size);
+
+	let mar = size / -2;
+	setStylePx(pt, "marginLeft", mar);
+	setStylePx(pt, "marginTop", mar);
+
+	let width = o.width(self, si, size);
+	width && setStylePx(pt, "borderWidth", width);
+
+	return pt;
+}
+
+function cursorPointFill(self, si) {
+	let sp = self.series[si].points;
+	return sp._fill || sp._stroke;
+}
+
+function cursorPointStroke(self, si) {
+	let sp = self.series[si].points;
+	return sp._stroke || sp._fill;
+}
+
+function cursorPointSize(self, si) {
+	let sp = self.series[si].points;
+	return sp.size;
+}
+
+const moveTuple = [0,0];
+
+function cursorMove(self, mouseLeft1, mouseTop1) {
+	moveTuple[0] = mouseLeft1;
+	moveTuple[1] = mouseTop1;
+	return moveTuple;
+}
+
+function filtBtn0(self, targ, handle, onlyTarg = true) {
+	return e => {
+		e.button == 0 && (!onlyTarg || e.target == targ) && handle(e);
+	};
+}
+
+function filtTarg(self, targ, handle, onlyTarg = true) {
+	return e => {
+		(!onlyTarg || e.target == targ) && handle(e);
+	};
+}
+
+export const cursorOpts = {
+	show: true,
+	x: true,
+	y: true,
+	lock: false,
+	move: cursorMove,
+	points: {
+		one:    false,
+		show:   cursorPointShow,
+		size:   cursorPointSize,
+		width:  0,
+		stroke: cursorPointStroke,
+		fill:   cursorPointFill,
+	},
+
+	bind: {
+		mousedown:   filtBtn0,
+		mouseup:     filtBtn0,
+		click:       filtBtn0, // legend clicks, not .u-over clicks
+		dblclick:    filtBtn0,
+
+		mousemove:   filtTarg,
+		mouseleave:  filtTarg,
+		mouseenter:  filtTarg,
+	},
+
+	drag: {
+		setScale: true,
+		x: true,
+		y: false,
+		dist: 0,
+		uni: null,
+		click: (self, e) => {
+		//	e.preventDefault();
+			e.stopPropagation();
+			e.stopImmediatePropagation();
+		},
+		_x: false,
+		_y: false,
+	},
+
+	focus: {
+		dist: (self, seriesIdx, dataIdx, valPos, curPos) => valPos - curPos,
+		prox: -1,
+		bias: 0,
+	},
+
+	hover: {
+		skip: [void 0],
+		prox: null,
+		bias: 0,
+	},
+
+	left: -10,
+	top: -10,
+	idx: null,
+	dataIdx: null,
+	idxs: null,
+
+	event: null,
+};
+
+const axisLines = {
+	show: true,
+	stroke: "rgba(0,0,0,0.07)",
+	width: 2,
+//	dash: [],
+};
+
+const grid = assign({}, axisLines, {
+	filter: retArg1,
+});
+
+const ticks = assign({}, grid, {
+	size: 10,
+});
+
+const border = assign({}, axisLines, {
+	show: false,
+});
+
+const font      = '12px system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"';
+const labelFont = "bold " + font;
+const lineGap = 1.5;	// font-size multiplier
+
+export const xAxisOpts = {
+	show: true,
+	scale: "x",
+	stroke: hexBlack,
+	space: 50,
+	gap: 5,
+	alignTo: 1,
+	size: 50,
+	labelGap: 0,
+	labelSize: 30,
+	labelFont,
+	side: 2,
+//	class: "x-vals",
+//	incrs: timeIncrs,
+//	values: timeVals,
+//	filter: retArg1,
+	grid,
+	ticks,
+	border,
+	font,
+	lineGap,
+	rotate: 0,
+};
+
+export const numSeriesLabel = "Value";
+export const timeSeriesLabel = "Time";
+
+export const xSeriesOpts = {
+	show: true,
+	scale: "x",
+	auto: false,
+	sorted: 1,
+//	label: "Time",
+//	value: v => stamp(new Date(v * 1e3)),
+
+	// internal caches
+	min: inf,
+	max: -inf,
+	idxs: [],
+};
+
+export function numAxisVals(self, splits, axisIdx, foundSpace, foundIncr) {
+	return splits.map(v => v == null ? "" : fmtNum(v));
+}
+
+export function numAxisSplits(self, axisIdx, scaleMin, scaleMax, foundIncr, foundSpace, forceMin) {
+	let splits = [];
+
+	let numDec = fixedDec.get(foundIncr) || 0;
+
+	scaleMin = forceMin ? scaleMin : roundDec(incrRoundUp(scaleMin, foundIncr), numDec);
+
+	for (let val = scaleMin; val <= scaleMax; val = roundDec(val + foundIncr, numDec))
+		splits.push(Object.is(val, -0) ? 0 : val);		// coalesces -0
+
+	return splits;
+}
+
+// this doesnt work for sin, which needs to come off from 0 independently in pos and neg dirs
+export function logAxisSplits(self, axisIdx, scaleMin, scaleMax, foundIncr, foundSpace, forceMin) {
+	const splits = [];
+
+	const logBase = self.scales[self.axes[axisIdx].scale].log;
+
+	const logFn = logBase == 10 ? log10 : log2;
+
+	const exp = floor(logFn(scaleMin));
+
+	foundIncr = pow(logBase, exp);
+
+	// boo: 10 ** -24 === 1.0000000000000001e-24
+	// this grabs the proper 1e-24 one
+	if (logBase == 10)
+		foundIncr = numIncrs[closestIdx(foundIncr, numIncrs)];
+
+	let split = foundIncr;
+	let nextMagIncr = foundIncr * logBase;
+
+	if (logBase == 10)
+		nextMagIncr = numIncrs[closestIdx(nextMagIncr, numIncrs)];
+
+	do {
+		if (split >= scaleMin)
+			splits.push(split);
+
+		split = split + foundIncr;
+
+		if (logBase == 10 && !fixedDec.has(split))
+			split = roundDec(split, fixedDec.get(foundIncr));
+
+		if (split >= nextMagIncr) {
+			foundIncr = split;
+			nextMagIncr = foundIncr * logBase;
+
+			if (logBase == 10)
+				nextMagIncr = numIncrs[closestIdx(nextMagIncr, numIncrs)];
+		}
+	} while (split <= scaleMax);
+
+	return splits;
+}
+
+export function asinhAxisSplits(self, axisIdx, scaleMin, scaleMax, foundIncr, foundSpace, forceMin) {
+	let sc = self.scales[self.axes[axisIdx].scale];
+
+	let linthresh = sc.asinh;
+
+	let posSplits = scaleMax > linthresh ? logAxisSplits(self, axisIdx, max(linthresh, scaleMin), scaleMax, foundIncr, foundSpace, forceMin) : [linthresh];
+	let zero = scaleMax >= 0 && scaleMin <= 0 ? [0] : [];
+	let negSplits = scaleMin < -linthresh ? logAxisSplits(self, axisIdx, max(linthresh, -scaleMax), -scaleMin, foundIncr, foundSpace, forceMin): [linthresh];
+
+	return negSplits.reverse().map(v => -v).concat(zero, posSplits);
+}
+
+const RE_ALL   = /./;
+const RE_12357 = /[12357]/;
+const RE_125   = /[125]/;
+const RE_1     = /1/;
+
+const _filt = (splits, distr, re, keepMod) => splits.map((v, i) => ((distr == 4 && v == 0) || i % keepMod == 0 && re.test(v.toExponential()[v < 0 ? 1 : 0])) ? v : null);
+
+export function log10AxisValsFilt(self, splits, axisIdx, foundSpace, foundIncr) {
+	let axis = self.axes[axisIdx];
+	let scaleKey = axis.scale;
+	let sc = self.scales[scaleKey];
+
+//	if (sc.distr == 3 && sc.log == 2)
+//		return splits;
+
+	let valToPos = self.valToPos;
+
+	let minSpace = axis._space;
+
+	let _10 = valToPos(10, scaleKey);
+
+	let re = (
+		valToPos(9, scaleKey) - _10 >= minSpace ? RE_ALL :
+		valToPos(7, scaleKey) - _10 >= minSpace ? RE_12357 :
+		valToPos(5, scaleKey) - _10 >= minSpace ? RE_125 :
+		RE_1
+	);
+
+	if (re == RE_1) {
+		let magSpace = abs(valToPos(1, scaleKey) - _10);
+
+		if (magSpace < minSpace)
+			return _filt(splits.slice().reverse(), sc.distr, re, ceil(minSpace / magSpace)).reverse(); // max->min skip
+	}
+
+	return _filt(splits, sc.distr, re, 1);
+}
+
+export function log2AxisValsFilt(self, splits, axisIdx, foundSpace, foundIncr) {
+	let axis = self.axes[axisIdx];
+	let scaleKey = axis.scale;
+	let minSpace = axis._space;
+	let valToPos = self.valToPos;
+
+	let magSpace = abs(valToPos(1, scaleKey) - valToPos(2, scaleKey));
+
+	if (magSpace < minSpace)
+		return _filt(splits.slice().reverse(), 3, RE_ALL, ceil(minSpace / magSpace)).reverse(); // max->min skip
+
+	return splits;
+}
+
+export function numSeriesVal(self, val, seriesIdx, dataIdx) {
+	return dataIdx == null ? LEGEND_DISP : val == null ? "" : fmtNum(val);
+}
+
+export const yAxisOpts = {
+	show: true,
+	scale: "y",
+	stroke: hexBlack,
+	space: 30,
+	gap: 5,
+	alignTo: 1,
+	size: 50,
+	labelGap: 0,
+	labelSize: 30,
+	labelFont,
+	side: 3,
+//	class: "y-vals",
+//	incrs: numIncrs,
+//	values: (vals, space) => vals,
+//	filter: retArg1,
+	grid,
+	ticks,
+	border,
+	font,
+	lineGap,
+	rotate: 0,
+};
+
+// takes stroke width
+export function ptDia(width, mult) {
+	let dia = 3 + (width || 1) * 2;
+	return roundDec(dia * mult, 3);
+}
+
+function seriesPointsShow(self, si) {
+	let { scale, idxs } = self.series[0];
+	let xData = self._data[0];
+	let p0 = self.valToPos(xData[idxs[0]], scale, true);
+	let p1 = self.valToPos(xData[idxs[1]], scale, true);
+	let dim = abs(p1 - p0);
+
+	let s = self.series[si];
+//	const dia = ptDia(s.width, self.pxRatio);
+	let maxPts = dim / (s.points.space * self.pxRatio);
+	return idxs[1] - idxs[0] <= maxPts;
+}
+
+const facet = {
+	scale: null,
+	auto: true,
+	sorted: 0,
+
+	// internal caches
+	min: inf,
+	max: -inf,
+};
+
+const gaps = (self, seriesIdx, idx0, idx1, nullGaps) => nullGaps;
+
+export const xySeriesOpts = {
+	show: true,
+	auto: true,
+	sorted: 0,
+	gaps,
+	alpha: 1,
+	facets: [
+		assign({}, facet, {scale: 'x'}),
+		assign({}, facet, {scale: 'y'}),
+	],
+};
+
+export const ySeriesOpts = {
+	scale: "y",
+	auto: true,
+	sorted: 0,
+	show: true,
+	spanGaps: false,
+	gaps,
+	alpha: 1,
+	points: {
+		show: seriesPointsShow,
+		filter: null,
+	//  paths:
+	//	stroke: "#000",
+	//	fill: "#fff",
+	//	width: 1,
+	//	size: 10,
+	},
+//	label: "Value",
+//	value: v => v,
+	values: null,
+
+	// internal caches
+	min: inf,
+	max: -inf,
+	idxs: [],
+
+	path: null,
+	clip: null,
+};
+
+export function clampScale(self, val, scaleMin, scaleMax, scaleKey) {
+/*
+	if (val < 0) {
+		let cssHgt = self.bbox.height / self.pxRatio;
+		let absPos = self.valToPos(abs(val), scaleKey);
+		let fromBtm = cssHgt - absPos;
+		return self.posToVal(cssHgt + fromBtm, scaleKey);
+	}
+*/
+	return scaleMin / 10;
+}
+
+export const xScaleOpts = {
+	time: FEAT_TIME,
+	auto: true,
+	distr: 1,
+	log: 10,
+	asinh: 1,
+	min: null,
+	max: null,
+	dir: 1,
+	ori: 0,
+};
+
+export const yScaleOpts = assign({}, xScaleOpts, {
+	time: false,
+	ori: 1,
+});