agentscript
Version:
AgentScript Model in Model/View architecture
1,774 lines • 125 kB
JavaScript
const FEAT_TIME = true;
const pre = "u-";
const UPLOT = "uplot";
const ORI_HZ = pre + "hz";
const ORI_VT = pre + "vt";
const TITLE = pre + "title";
const WRAP = pre + "wrap";
const UNDER = pre + "under";
const OVER = pre + "over";
const AXIS = pre + "axis";
const OFF = pre + "off";
const SELECT = pre + "select";
const CURSOR_X = pre + "cursor-x";
const CURSOR_Y = pre + "cursor-y";
const CURSOR_PT = pre + "cursor-pt";
const LEGEND = pre + "legend";
const LEGEND_LIVE = pre + "live";
const LEGEND_INLINE = pre + "inline";
const LEGEND_SERIES = pre + "series";
const LEGEND_MARKER = pre + "marker";
const LEGEND_LABEL = pre + "label";
const LEGEND_VALUE = pre + "value";
const WIDTH = "width";
const HEIGHT = "height";
const TOP = "top";
const BOTTOM = "bottom";
const LEFT = "left";
const RIGHT = "right";
const hexBlack = "#000";
const transparent = hexBlack + "0";
const mousemove = "mousemove";
const mousedown = "mousedown";
const mouseup = "mouseup";
const mouseenter = "mouseenter";
const mouseleave = "mouseleave";
const dblclick = "dblclick";
const resize = "resize";
const scroll = "scroll";
const change = "change";
const dppxchange = "dppxchange";
const LEGEND_DISP = "--";
const domEnv = typeof window != 'undefined';
const doc = domEnv ? document : null;
const win = domEnv ? window : null;
const nav = domEnv ? navigator : null;
let pxRatio;
let query;
function setPxRatio() {
let _pxRatio = devicePixelRatio;
if (pxRatio != _pxRatio) {
pxRatio = _pxRatio;
query && off(change, query, setPxRatio);
query = matchMedia(`(min-resolution: ${pxRatio - 0.001}dppx) and (max-resolution: ${pxRatio + 0.001}dppx)`);
on(change, query, setPxRatio);
win.dispatchEvent(new CustomEvent(dppxchange));
}
}
function addClass(el, c) {
if (c != null) {
let cl = el.classList;
!cl.contains(c) && cl.add(c);
}
}
function remClass(el, c) {
let cl = el.classList;
cl.contains(c) && cl.remove(c);
}
function setStylePx(el, name, value) {
el.style[name] = value + "px";
}
function placeTag(tag, cls, targ, refEl) {
let el = doc.createElement(tag);
if (cls != null)
addClass(el, cls);
if (targ != null)
targ.insertBefore(el, refEl);
return el;
}
function placeDiv(cls, targ) {
return placeTag("div", cls, targ);
}
const xformCache = new WeakMap();
function elTrans(el, xPos, yPos, xMax, yMax) {
let xform = "translate(" + xPos + "px," + yPos + "px)";
let xformOld = xformCache.get(el);
if (xform != xformOld) {
el.style.transform = xform;
xformCache.set(el, xform);
if (xPos < 0 || yPos < 0 || xPos > xMax || yPos > yMax)
addClass(el, OFF);
else
remClass(el, OFF);
}
}
const colorCache = new WeakMap();
function elColor(el, background, borderColor) {
let newColor = background + borderColor;
let oldColor = colorCache.get(el);
if (newColor != oldColor) {
colorCache.set(el, newColor);
el.style.background = background;
el.style.borderColor = borderColor;
}
}
const sizeCache = new WeakMap();
function elSize(el, newWid, newHgt, centered) {
let newSize = newWid + "" + newHgt;
let oldSize = sizeCache.get(el);
if (newSize != oldSize) {
sizeCache.set(el, newSize);
el.style.height = newHgt + "px";
el.style.width = newWid + "px";
el.style.marginLeft = centered ? -newWid/2 + "px" : 0;
el.style.marginTop = centered ? -newHgt/2 + "px" : 0;
}
}
const evOpts = {passive: true};
const evOpts2 = {...evOpts, capture: true};
function on(ev, el, cb, capt) {
el.addEventListener(ev, cb, capt ? evOpts2 : evOpts);
}
function off(ev, el, cb, capt) {
el.removeEventListener(ev, cb, evOpts);
}
domEnv && setPxRatio();
function closestIdx(num, arr, lo, hi) {
let mid;
lo = lo || 0;
hi = hi || arr.length - 1;
let bitwise = hi <= 2147483647;
while (hi - lo > 1) {
mid = bitwise ? (lo + hi) >> 1 : floor((lo + hi) / 2);
if (arr[mid] < num)
lo = mid;
else
hi = mid;
}
if (num - arr[lo] <= arr[hi] - num)
return lo;
return hi;
}
function nonNullIdx(data, _i0, _i1, dir) {
for (let i = dir == 1 ? _i0 : _i1; i >= _i0 && i <= _i1; i += dir) {
if (data[i] != null)
return i;
}
return -1;
}
function getMinMax(data, _i0, _i1, sorted) {
let _min = inf;
let _max = -inf;
if (sorted == 1) {
_min = data[_i0];
_max = data[_i1];
}
else if (sorted == -1) {
_min = data[_i1];
_max = data[_i0];
}
else {
for (let i = _i0; i <= _i1; i++) {
let v = data[i];
if (v != null) {
if (v < _min)
_min = v;
if (v > _max)
_max = v;
}
}
}
return [_min, _max];
}
function getMinMaxLog(data, _i0, _i1) {
let _min = inf;
let _max = -inf;
for (let i = _i0; i <= _i1; i++) {
let v = data[i];
if (v != null && v > 0) {
if (v < _min)
_min = v;
if (v > _max)
_max = v;
}
}
return [_min, _max];
}
function rangeLog(min, max, base, fullMags) {
let minSign = sign(min);
let maxSign = sign(max);
if (min == max) {
if (minSign == -1) {
min *= base;
max /= base;
}
else {
min /= base;
max *= base;
}
}
let logFn = base == 10 ? log10 : log2;
let growMinAbs = minSign == 1 ? floor : ceil;
let growMaxAbs = maxSign == 1 ? ceil : floor;
let minExp = growMinAbs(logFn(abs(min)));
let maxExp = growMaxAbs(logFn(abs(max)));
let minIncr = pow(base, minExp);
let maxIncr = pow(base, maxExp);
if (base == 10) {
if (minExp < 0)
minIncr = roundDec(minIncr, -minExp);
if (maxExp < 0)
maxIncr = roundDec(maxIncr, -maxExp);
}
if (fullMags || base == 2) {
min = minIncr * minSign;
max = maxIncr * maxSign;
}
else {
min = incrRoundDn(min, minIncr);
max = incrRoundUp(max, maxIncr);
}
return [min, max];
}
function rangeAsinh(min, max, base, fullMags) {
let minMax = rangeLog(min, max, base, fullMags);
if (min == 0)
minMax[0] = 0;
if (max == 0)
minMax[1] = 0;
return minMax;
}
const rangePad = 0.1;
const autoRangePart = {
mode: 3,
pad: rangePad,
};
const _eqRangePart = {
pad: 0,
soft: null,
mode: 0,
};
const _eqRange = {
min: _eqRangePart,
max: _eqRangePart,
};
function rangeNum(_min, _max, mult, extra) {
if (isObj(mult))
return _rangeNum(_min, _max, mult);
_eqRangePart.pad = mult;
_eqRangePart.soft = extra ? 0 : null;
_eqRangePart.mode = extra ? 3 : 0;
return _rangeNum(_min, _max, _eqRange);
}
function ifNull(lh, rh) {
return lh == null ? rh : lh;
}
function hasData(data, idx0, idx1) {
idx0 = ifNull(idx0, 0);
idx1 = ifNull(idx1, data.length - 1);
while (idx0 <= idx1) {
if (data[idx0] != null)
return true;
idx0++;
}
return false;
}
function _rangeNum(_min, _max, cfg) {
let cmin = cfg.min;
let cmax = cfg.max;
let padMin = ifNull(cmin.pad, 0);
let padMax = ifNull(cmax.pad, 0);
let hardMin = ifNull(cmin.hard, -inf);
let hardMax = ifNull(cmax.hard, inf);
let softMin = ifNull(cmin.soft, inf);
let softMax = ifNull(cmax.soft, -inf);
let softMinMode = ifNull(cmin.mode, 0);
let softMaxMode = ifNull(cmax.mode, 0);
let delta = _max - _min;
let deltaMag = log10(delta);
let scalarMax = max(abs(_min), abs(_max));
let scalarMag = log10(scalarMax);
let scalarMagDelta = abs(scalarMag - deltaMag);
if (delta < 1e-24 || scalarMagDelta > 10) {
delta = 0;
if (_min == 0 || _max == 0) {
delta = 1e-24;
if (softMinMode == 2 && softMin != inf)
padMin = 0;
if (softMaxMode == 2 && softMax != -inf)
padMax = 0;
}
}
let nonZeroDelta = delta || scalarMax || 1e3;
let mag = log10(nonZeroDelta);
let base = pow(10, floor(mag));
let _padMin = nonZeroDelta * (delta == 0 ? (_min == 0 ? .1 : 1) : padMin);
let _newMin = roundDec(incrRoundDn(_min - _padMin, base/10), 24);
let _softMin = _min >= softMin && (softMinMode == 1 || softMinMode == 3 && _newMin <= softMin || softMinMode == 2 && _newMin >= softMin) ? softMin : inf;
let minLim = max(hardMin, _newMin < _softMin && _min >= _softMin ? _softMin : min(_softMin, _newMin));
let _padMax = nonZeroDelta * (delta == 0 ? (_max == 0 ? .1 : 1) : padMax);
let _newMax = roundDec(incrRoundUp(_max + _padMax, base/10), 24);
let _softMax = _max <= softMax && (softMaxMode == 1 || softMaxMode == 3 && _newMax >= softMax || softMaxMode == 2 && _newMax <= softMax) ? softMax : -inf;
let maxLim = min(hardMax, _newMax > _softMax && _max <= _softMax ? _softMax : max(_softMax, _newMax));
if (minLim == maxLim && minLim == 0)
maxLim = 100;
return [minLim, maxLim];
}
const numFormatter = new Intl.NumberFormat(domEnv ? nav.language : 'en-US');
const fmtNum = val => numFormatter.format(val);
const M = Math;
const PI = M.PI;
const abs = M.abs;
const floor = M.floor;
const round = M.round;
const ceil = M.ceil;
const min = M.min;
const max = M.max;
const pow = M.pow;
const sign = M.sign;
const log10 = M.log10;
const log2 = M.log2;
const sinh = (v, linthresh = 1) => M.sinh(v) * linthresh;
const asinh = (v, linthresh = 1) => M.asinh(v / linthresh);
const inf = Infinity;
function numIntDigits(x) {
return (log10((x ^ (x >> 31)) - (x >> 31)) | 0) + 1;
}
function clamp(num, _min, _max) {
return min(max(num, _min), _max);
}
function fnOrSelf(v) {
return typeof v == "function" ? v : () => v;
}
const noop = () => {};
const retArg0 = _0 => _0;
const retArg1 = (_0, _1) => _1;
const retNull = _ => null;
const retTrue = _ => true;
const retEq = (a, b) => a == b;
const regex6 = /\.\d*?(?=9{6,}|0{6,})/gm;
const fixFloat = val => {
if (isInt(val) || fixedDec.has(val))
return val;
const str = `${val}`;
const match = str.match(regex6);
if (match == null)
return val;
let len = match[0].length - 1;
if (str.indexOf('e-') != -1) {
let [num, exp] = str.split('e');
return +`${fixFloat(num)}e${exp}`;
}
return roundDec(val, len);
};
function incrRound(num, incr) {
return fixFloat(roundDec(fixFloat(num/incr))*incr);
}
function incrRoundUp(num, incr) {
return fixFloat(ceil(fixFloat(num/incr))*incr);
}
function incrRoundDn(num, incr) {
return fixFloat(floor(fixFloat(num/incr))*incr);
}
function roundDec(val, dec = 0) {
if (isInt(val))
return val;
let p = 10 ** dec;
let n = (val * p) * (1 + Number.EPSILON);
return round(n) / p;
}
const fixedDec = new Map();
function guessDec(num) {
return ((""+num).split(".")[1] || "").length;
}
function genIncrs(base, minExp, maxExp, mults) {
let incrs = [];
let multDec = mults.map(guessDec);
for (let exp = minExp; exp < maxExp; exp++) {
let expa = abs(exp);
let mag = roundDec(pow(base, exp), expa);
for (let i = 0; i < mults.length; i++) {
let _incr = base == 10 ? +`${mults[i]}e${exp}` : mults[i] * mag;
let dec = (exp >= 0 ? 0 : expa) + (exp >= multDec[i] ? 0 : multDec[i]);
let incr = base == 10 ? _incr : roundDec(_incr, dec);
incrs.push(incr);
fixedDec.set(incr, dec);
}
}
return incrs;
}
const EMPTY_OBJ = {};
const EMPTY_ARR = [];
const nullNullTuple = [null, null];
const isArr = Array.isArray;
const isInt = Number.isInteger;
const isUndef = v => v === void 0;
function isStr(v) {
return typeof v == 'string';
}
function isObj(v) {
let is = false;
if (v != null) {
let c = v.constructor;
is = c == null || c == Object;
}
return is;
}
function fastIsObj(v) {
return v != null && typeof v == 'object';
}
const TypedArray = Object.getPrototypeOf(Uint8Array);
const __proto__ = "__proto__";
function copy(o, _isObj = isObj) {
let out;
if (isArr(o)) {
let val = o.find(v => v != null);
if (isArr(val) || _isObj(val)) {
out = Array(o.length);
for (let i = 0; i < o.length; i++)
out[i] = copy(o[i], _isObj);
}
else
out = o.slice();
}
else if (o instanceof TypedArray)
out = o.slice();
else if (_isObj(o)) {
out = {};
for (let k in o) {
if (k != __proto__)
out[k] = copy(o[k], _isObj);
}
}
else
out = o;
return out;
}
function assign(targ) {
let args = arguments;
for (let i = 1; i < args.length; i++) {
let src = args[i];
for (let key in src) {
if (key != __proto__) {
if (isObj(targ[key]))
assign(targ[key], copy(src[key]));
else
targ[key] = copy(src[key]);
}
}
}
return targ;
}
const NULL_REMOVE = 0;
const NULL_RETAIN = 1;
const NULL_EXPAND = 2;
function nullExpand(yVals, nullIdxs, alignedLen) {
for (let i = 0, xi, lastNullIdx = -1; i < nullIdxs.length; i++) {
let nullIdx = nullIdxs[i];
if (nullIdx > lastNullIdx) {
xi = nullIdx - 1;
while (xi >= 0 && yVals[xi] == null)
yVals[xi--] = null;
xi = nullIdx + 1;
while (xi < alignedLen && yVals[xi] == null)
yVals[lastNullIdx = xi++] = null;
}
}
}
function join(tables, nullModes) {
if (allHeadersSame(tables)) {
let table = tables[0].slice();
for (let i = 1; i < tables.length; i++)
table.push(...tables[i].slice(1));
if (!isAsc(table[0]))
table = sortCols(table);
return table;
}
let xVals = new Set();
for (let ti = 0; ti < tables.length; ti++) {
let t = tables[ti];
let xs = t[0];
let len = xs.length;
for (let i = 0; i < len; i++)
xVals.add(xs[i]);
}
let data = [Array.from(xVals).sort((a, b) => a - b)];
let alignedLen = data[0].length;
let xIdxs = new Map();
for (let i = 0; i < alignedLen; i++)
xIdxs.set(data[0][i], i);
for (let ti = 0; ti < tables.length; ti++) {
let t = tables[ti];
let xs = t[0];
for (let si = 1; si < t.length; si++) {
let ys = t[si];
let yVals = Array(alignedLen).fill(undefined);
let nullMode = nullModes ? nullModes[ti][si] : NULL_RETAIN;
let nullIdxs = [];
for (let i = 0; i < ys.length; i++) {
let yVal = ys[i];
let alignedIdx = xIdxs.get(xs[i]);
if (yVal === null) {
if (nullMode != NULL_REMOVE) {
yVals[alignedIdx] = yVal;
if (nullMode == NULL_EXPAND)
nullIdxs.push(alignedIdx);
}
}
else
yVals[alignedIdx] = yVal;
}
nullExpand(yVals, nullIdxs, alignedLen);
data.push(yVals);
}
}
return data;
}
const microTask = typeof queueMicrotask == "undefined" ? fn => Promise.resolve().then(fn) : queueMicrotask;
function sortCols(table) {
let head = table[0];
let rlen = head.length;
let idxs = Array(rlen);
for (let i = 0; i < idxs.length; i++)
idxs[i] = i;
idxs.sort((i0, i1) => head[i0] - head[i1]);
let table2 = [];
for (let i = 0; i < table.length; i++) {
let row = table[i];
let row2 = Array(rlen);
for (let j = 0; j < rlen; j++)
row2[j] = row[idxs[j]];
table2.push(row2);
}
return table2;
}
function allHeadersSame(tables) {
let vals0 = tables[0][0];
let len0 = vals0.length;
for (let i = 1; i < tables.length; i++) {
let vals1 = tables[i][0];
if (vals1.length != len0)
return false;
if (vals1 != vals0) {
for (let j = 0; j < len0; j++) {
if (vals1[j] != vals0[j])
return false;
}
}
}
return true;
}
function isAsc(vals, samples = 100) {
const len = vals.length;
if (len <= 1)
return true;
let firstIdx = 0;
let lastIdx = len - 1;
while (firstIdx <= lastIdx && vals[firstIdx] == null)
firstIdx++;
while (lastIdx >= firstIdx && vals[lastIdx] == null)
lastIdx--;
if (lastIdx <= firstIdx)
return true;
const stride = max(1, floor((lastIdx - firstIdx + 1) / samples));
for (let prevVal = vals[firstIdx], i = firstIdx + stride; i <= lastIdx; i += stride) {
const v = vals[i];
if (v != null) {
if (v <= prevVal)
return false;
prevVal = v;
}
}
return true;
}
const months = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
const days = [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
];
function slice3(str) {
return str.slice(0, 3);
}
const days3 = days.map(slice3);
const months3 = months.map(slice3);
const engNames = {
MMMM: months,
MMM: months3,
WWWW: days,
WWW: days3,
};
function zeroPad2(int) {
return (int < 10 ? '0' : '') + int;
}
function zeroPad3(int) {
return (int < 10 ? '00' : int < 100 ? '0' : '') + int;
}
const subs = {
YYYY: d => d.getFullYear(),
YY: d => (d.getFullYear()+'').slice(2),
MMMM: (d, names) => names.MMMM[d.getMonth()],
MMM: (d, names) => names.MMM[d.getMonth()],
MM: d => zeroPad2(d.getMonth()+1),
M: d => d.getMonth()+1,
DD: d => zeroPad2(d.getDate()),
D: d => d.getDate(),
WWWW: (d, names) => names.WWWW[d.getDay()],
WWW: (d, names) => names.WWW[d.getDay()],
HH: d => zeroPad2(d.getHours()),
H: d => d.getHours(),
h: d => {let h = d.getHours(); return h == 0 ? 12 : h > 12 ? h - 12 : h;},
AA: d => d.getHours() >= 12 ? 'PM' : 'AM',
aa: d => d.getHours() >= 12 ? 'pm' : 'am',
a: d => d.getHours() >= 12 ? 'p' : 'a',
mm: d => zeroPad2(d.getMinutes()),
m: d => d.getMinutes(),
ss: d => zeroPad2(d.getSeconds()),
s: d => d.getSeconds(),
fff: d => zeroPad3(d.getMilliseconds()),
};
function fmtDate(tpl, names) {
names = names || engNames;
let parts = [];
let R = /\{([a-z]+)\}|[^{]+/gi, m;
while (m = R.exec(tpl))
parts.push(m[0][0] == '{' ? subs[m[1]] : m[0]);
return d => {
let out = '';
for (let i = 0; i < parts.length; i++)
out += typeof parts[i] == "string" ? parts[i] : parts[i](d, names);
return out;
}
}
const localTz = new Intl.DateTimeFormat().resolvedOptions().timeZone;
function tzDate(date, tz) {
let date2;
if (tz == 'UTC' || tz == 'Etc/UTC')
date2 = new Date(+date + date.getTimezoneOffset() * 6e4);
else if (tz == localTz)
date2 = date;
else {
date2 = new Date(date.toLocaleString('en-US', {timeZone: tz}));
date2.setMilliseconds(date.getMilliseconds());
}
return date2;
}
const onlyWhole = v => v % 1 == 0;
const allMults = [1,2,2.5,5];
const decIncrs = genIncrs(10, -32, 0, allMults);
const oneIncrs = genIncrs(10, 0, 32, allMults);
const wholeIncrs = oneIncrs.filter(onlyWhole);
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;
let subSecIncrs = ms == 1 ? genIncrs(10, 0, 3, allMults).filter(onlyWhole) : genIncrs(10, -3, 0, allMults);
let timeIncrs = subSecIncrs.concat([
s,
s * 5,
s * 10,
s * 15,
s * 30,
m,
m * 5,
m * 10,
m * 15,
m * 30,
h,
h * 2,
h * 3,
h * 4,
h * 6,
h * 8,
h * 12,
d,
d * 2,
d * 3,
d * 4,
d * 5,
d * 6,
d * 7,
d * 8,
d * 9,
d * 10,
d * 15,
mo,
mo * 2,
mo * 3,
mo * 4,
mo * 6,
y,
y * 2,
y * 5,
y * 10,
y * 25,
y * 50,
y * 100,
]);
const _timeAxisStamps = [
[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],
];
function timeAxisSplits(tzDate) {
return (self, axisIdx, scaleMin, scaleMax, foundIncr, foundSpace) => {
let splits = [];
let isYr = foundIncr >= y;
let isMo = foundIncr >= mo && foundIncr < y;
let minDate = tzDate(scaleMin);
let minDateTs = roundDec(minDate * ms, 3);
let minMin = mkDate(minDate.getFullYear(), isYr ? 0 : minDate.getMonth(), isMo || isYr ? 1 : minDate.getDate());
let minMinTs = roundDec(minMin * ms, 3);
if (isMo || isYr) {
let moIncr = isMo ? foundIncr / mo : 0;
let yrIncr = isYr ? foundIncr / y : 0;
let split = minDateTs == minMinTs ? minDateTs : roundDec(mkDate(minMin.getFullYear() + yrIncr, minMin.getMonth() + moIncr, 1) * ms, 3);
let splitDate = new Date(round(split / ms));
let baseYear = splitDate.getFullYear();
let baseMonth = splitDate.getMonth();
for (let i = 0; split <= scaleMax; i++) {
let next = mkDate(baseYear + yrIncr * i, baseMonth + moIncr * i, 1);
let offs = next - tzDate(roundDec(next * ms, 3));
split = roundDec((+next + offs) * ms, 3);
if (split <= scaleMax)
splits.push(split);
}
}
else {
let incr0 = foundIncr >= d ? d : foundIncr;
let tzOffset = floor(scaleMin) - floor(minDateTs);
let split = minMinTs + tzOffset + incrRoundUp(minDateTs - minMinTs, incr0);
splits.push(split);
let date0 = tzDate(split);
let prevHour = date0.getHours() + (date0.getMinutes() / m) + (date0.getSeconds() / h);
let incrHours = foundIncr / h;
let minSpace = self.axes[axisIdx]._space;
let pctSpace = foundSpace / minSpace;
while (1) {
split = roundDec(split + foundIncr, ms == 1 ? 0 : 3);
if (split > scaleMax)
break;
if (incrHours > 1) {
let expectedHour = floor(roundDec(prevHour + incrHours, 6)) % 24;
let splitDate = tzDate(split);
let actualHour = splitDate.getHours();
let dstShift = actualHour - expectedHour;
if (dstShift > 1)
dstShift = -1;
split -= dstShift * h;
prevHour = (prevHour + incrHours) % 24;
let prevSplit = splits[splits.length - 1];
let pctIncr = roundDec((split - prevSplit) / foundIncr, 3);
if (pctIncr * pctSpace >= .7)
splits.push(split);
}
else
splits.push(split);
}
}
return splits;
}
}
return [
timeIncrs,
_timeAxisStamps,
timeAxisSplits,
];
}
const [ timeIncrsMs, _timeAxisStampsMs, timeAxisSplitsMs ] = genTimeStuffs(1);
const [ timeIncrsS, _timeAxisStampsS, timeAxisSplitsS ] = genTimeStuffs(1e-3);
genIncrs(2, -53, 53, [1]);
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)
));
}
function timeAxisVals(tzDate, stamps) {
return (self, splits, axisIdx, foundSpace, foundIncr) => {
let s = stamps.find(s => foundIncr >= s[0]) || stamps[stamps.length - 1];
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);
});
}
}
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);
}
function timeSeriesStamp(stampCfg, fmtDate) {
return fmtDate(stampCfg);
}
const _timeSeriesStamp = '{YYYY}-{MM}-{DD} {h}:{mm}{aa}';
function timeSeriesVal(tzDate, stamp) {
return (self, val, seriesIdx, dataIdx) => dataIdx == null ? LEGEND_DISP : stamp(tzDate(val));
}
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;
}
function legendFill(self, seriesIdx) {
return self.series[seriesIdx].fill(self, seriesIdx);
}
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);
};
}
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,
dblclick: filtBtn0,
mousemove: filtTarg,
mouseleave: filtTarg,
mouseenter: filtTarg,
},
drag: {
setScale: true,
x: true,
y: false,
dist: 0,
uni: null,
click: (self, e) => {
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,
};
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;
const xAxisOpts = {
show: true,
scale: "x",
stroke: hexBlack,
space: 50,
gap: 5,
size: 50,
labelGap: 0,
labelSize: 30,
labelFont,
side: 2,
grid,
ticks,
border,
font,
lineGap,
rotate: 0,
};
const numSeriesLabel = "Value";
const timeSeriesLabel = "Time";
const xSeriesOpts = {
show: true,
scale: "x",
auto: false,
sorted: 1,
min: inf,
max: -inf,
idxs: [],
};
function numAxisVals(self, splits, axisIdx, foundSpace, foundIncr) {
return splits.map(v => v == null ? "" : fmtNum(v));
}
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);
return splits;
}
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);
if (logBase == 10)
foundIncr = numIncrs[closestIdx(foundIncr, numIncrs)];
let split = scaleMin;
let nextMagIncr = foundIncr * logBase;
if (logBase == 10)
nextMagIncr = numIncrs[closestIdx(nextMagIncr, numIncrs)];
do {
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;
}
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) : [linthresh];
let zero = scaleMax >= 0 && scaleMin <= 0 ? [0] : [];
let negSplits = scaleMin < -linthresh ? logAxisSplits(self, axisIdx, max(linthresh, -scaleMax), -scaleMin, foundIncr): [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);
function log10AxisValsFilt(self, splits, axisIdx, foundSpace, foundIncr) {
let axis = self.axes[axisIdx];
let scaleKey = axis.scale;
let sc = self.scales[scaleKey];
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();
}
return _filt(splits, sc.distr, re, 1);
}
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();
return splits;
}
function numSeriesVal(self, val, seriesIdx, dataIdx) {
return dataIdx == null ? LEGEND_DISP : val == null ? "" : fmtNum(val);
}
const yAxisOpts = {
show: true,
scale: "y",
stroke: hexBlack,
space: 30,
gap: 5,
size: 50,
labelGap: 0,
labelSize: 30,
labelFont,
side: 3,
grid,
ticks,
border,
font,
lineGap,
rotate: 0,
};
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];
let maxPts = dim / (s.points.space * pxRatio);
return idxs[1] - idxs[0] <= maxPts;
}
const facet = {
scale: null,
auto: true,
sorted: 0,
min: inf,
max: -inf,
};
const gaps = (self, seriesIdx, idx0, idx1, nullGaps) => nullGaps;
const xySeriesOpts = {
show: true,
auto: true,
sorted: 0,
gaps,
alpha: 1,
facets: [
assign({}, facet, {scale: 'x'}),
assign({}, facet, {scale: 'y'}),
],
};
const ySeriesOpts = {
scale: "y",
auto: true,
sorted: 0,
show: true,
spanGaps: false,
gaps,
alpha: 1,
points: {
show: seriesPointsShow,
filter: null,
},
values: null,
min: inf,
max: -inf,
idxs: [],
path: null,
clip: null,
};
function clampScale(self, val, scaleMin, scaleMax, scaleKey) {
return scaleMin / 10;
}
const xScaleOpts = {
time: FEAT_TIME,
auto: true,
distr: 1,
log: 10,
asinh: 1,
min: null,
max: null,
dir: 1,
ori: 0,
};
const yScaleOpts = assign({}, xScaleOpts, {
time: false,
ori: 1,
});
const syncs = {};
function _sync(key, opts) {
let s = syncs[key];
if (!s) {
s = {
key,
plots: [],
sub(plot) {
s.plots.push(plot);
},
unsub(plot) {
s.plots = s.plots.filter(c => c != plot);
},
pub(type, self, x, y, w, h, i) {
for (let j = 0; j < s.plots.length; j++)
s.plots[j] != self && s.plots[j].pub(type, self, x, y, w, h, i);
},
};
if (key != null)
syncs[key] = s;
}
return s;
}
const BAND_CLIP_FILL = 1 << 0;
const BAND_CLIP_STROKE = 1 << 1;
function orient(u, seriesIdx, cb) {
const mode = u.mode;
const series = u.series[seriesIdx];
const data = mode == 2 ? u._data[seriesIdx] : u._data;
const scales = u.scales;
const bbox = u.bbox;
let dx = data[0],
dy = mode == 2 ? data[1] : data[seriesIdx],
sx = mode == 2 ? scales[series.facets[0].scale] : scales[u.series[0].scale],
sy = mode == 2 ? scales[series.facets[1].scale] : scales[series.scale],
l = bbox.left,
t = bbox.top,
w = bbox.width,
h = bbox.height,
H = u.valToPosH,
V = u.valToPosV;
return (sx.ori == 0
? cb(
series,
dx,
dy,
sx,
sy,
H,
V,
l,
t,
w,
h,
moveToH,
lineToH,
rectH,
arcH,
bezierCurveToH,
)
: cb(
series,
dx,
dy,
sx,
sy,
V,
H,
t,
l,
h,
w,
moveToV,
lineToV,
rectV,
arcV,
bezierCurveToV,
)
);
}
function bandFillClipDirs(self, seriesIdx) {
let fillDir = 0;
let clipDirs = 0;
let bands = ifNull(self.bands, EMPTY_ARR);
for (let i = 0; i < bands.length; i++) {
let b = bands[i];
if (b.series[0] == seriesIdx)
fillDir = b.dir;
else if (b.series[1] == seriesIdx) {
if (b.dir == 1)
clipDirs |= 1;
else
clipDirs |= 2;
}
}
return [
fillDir,
(
clipDirs == 1 ? -1 :
clipDirs == 2 ? 1 :
clipDirs == 3 ? 2 :
0
)
];
}
function seriesFillTo(self, seriesIdx, dataMin, dataMax, bandFillDir) {
let mode = self.mode;
let series = self.series[seriesIdx];
let scaleKey = mode == 2 ? series.facets[1].scale : series.scale;
let scale = self.scales[scaleKey];
return (
bandFillDir == -1 ? scale.min :
bandFillDir == 1 ? scale.max :
scale.distr == 3 ? (
scale.dir == 1 ? scale.min :
scale.max
) : 0
);
}
function clipBandLine(self, seriesIdx, idx0, idx1, strokePath, clipDir) {
return orient(self, seriesIdx, (series, dataX, dataY, scaleX, scaleY, valToPosX, valToPosY, xOff, yOff, xDim, yDim) => {
let pxRound = series.pxRound;
const dir = scaleX.dir * (scaleX.ori == 0 ? 1 : -1);
const lineTo = scaleX.ori == 0 ? lineToH : lineToV;
let frIdx, toIdx;
if (dir == 1) {
frIdx = idx0;
toIdx = idx1;
}
else {
frIdx = idx1;
toIdx = idx0;
}
let x0 = pxRound(valToPosX(dataX[frIdx], scaleX, xDim, xOff));
let y0 = pxRound(valToPosY(dataY[frIdx], scaleY, yDim, yOff));
let x1 = pxRound(valToPosX(dataX[toIdx], scaleX, xDim, xOff));
let yLimit = pxRound(valToPosY(clipDir == 1 ? scaleY.max : scaleY.min, scaleY, yDim, yOff));
let clip = new Path2D(strokePath);
lineTo(clip, x1, yLimit);
lineTo(clip, x0, yLimit);
lineTo(clip, x0, y0);
return clip;
});
}
function clipGaps(gaps, ori, plotLft, plotTop, plotWid, plotHgt) {
let clip = null;
if (gaps.length > 0) {
clip = new Path2D();
const rect = ori == 0 ? rectH : rectV;
let prevGapEnd = plotLft;
for (let i = 0; i < gaps.length; i++) {
let g = gaps[i];
if (g[1] > g[0]) {
let w = g[0] - prevGapEnd;
w > 0 && rect(clip, prevGapEnd, plotTop, w, plotTop + plotHgt);
prevGapEnd = g[1];
}
}
let w = plotLft + plotWid - prevGapEnd;
let maxStrokeWidth = 10;
w > 0 && rect(clip, prevGapEnd, plotTop - maxStrokeWidth / 2, w, plotTop + plotHgt + maxStrokeWidth);
}
return clip;
}
function addGap(gaps, fromX, toX) {
let prevGap = gaps[gaps.length - 1];
if (prevGap && prevGap[0] == fromX)
prevGap[1] = toX;
else
gaps.push([fromX, toX]);
}
function findGaps(xs, ys, idx0, idx1, dir, pixelForX, align) {
let gaps = [];
let len = xs.length;
for (let i = dir == 1 ? idx0 : idx1; i >= idx0 && i <= idx1; i += dir) {
let yVal = ys[i];
if (yVal === null) {
let fr = i, to = i;
if (dir == 1) {
while (++i <= idx1 && ys[i] === null)
to = i;
}
else {
while (--i >= idx0 && ys[i] === null)
to = i;
}
let frPx = pixelForX(xs[fr]);
let toPx = to == fr ? frPx : pixelForX(xs[to]);
let fri2 = fr - dir;
let frPx2 = align <= 0 && fri2 >= 0 && fri2 < len ? pixelForX(xs[fri2]) : frPx;
frPx = frPx2;
let toi2 = to + dir;
let toPx2 = align >= 0 && toi2 >= 0 && toi2 < len ? pixelForX(xs[toi2]) : toPx;
toPx = toPx2;
if (toPx >= frPx)
gaps.push([frPx, toPx]);
}
}
return gaps;
}
function pxRoundGen(pxAlign) {
return pxAlign == 0 ? retArg0 : pxAlign == 1 ? round : v => incrRound(v, pxAlign);
}
function rect(ori) {
let moveTo = ori == 0 ?
moveToH :
moveToV;
let arcTo = ori == 0 ?
(p, x1, y1, x2, y2, r) => { p.arcTo(x1, y1, x2, y2, r); } :
(p, y1, x1, y2, x2, r) => { p.arcTo(x1, y1, x2, y2, r); };
let rect = ori == 0 ?
(p, x, y, w, h) => { p.rect(x, y, w, h); } :
(p, y, x, h, w) => { p.rect(x, y, w, h); };
return (p, x, y, w, h, endRad = 0, baseRad = 0) => {
if (endRad == 0 && baseRad == 0)
rect(p, x, y, w, h);
else {
endRad = min(endRad, w / 2, h / 2);
baseRad = min(baseRad, w / 2, h / 2);
moveTo(p, x + endRad, y);
arcTo(p, x + w, y, x + w, y + h, endRad);
arcTo(p, x + w, y + h, x, y + h, baseRad);
arcTo(p, x, y + h, x, y, baseRad);
arcTo(p, x, y, x + w, y, endRad);
p.closePath();
}
};
}
const moveToH = (p, x, y) => { p.moveTo(x, y); };
const moveToV = (p, y, x) => { p.moveTo(x, y); };
const lineToH = (p, x, y) => { p.lineTo(x, y); };
const lineToV = (p, y, x) => { p.lineTo(x, y); };
const rectH = rect(0);
const rectV = rect(1);
const arcH = (p, x, y, r, startAngle, endAngle) => { p.arc(x, y, r, startAngle, endAngle); };
const arcV = (p, y, x, r, startAngle, endAngle) => { p.arc(x, y, r, startAngle, endAngle); };
const bezierCurveToH = (p, bp1x, bp1y, bp2x, bp2y, p2x, p2y) => { p.bezierCurveTo(bp1x, bp1y, bp2x, bp2y, p2x, p2y); };
const bezierCurveToV = (p, bp1y, bp1x, bp2y, bp2x, p2y, p2x) => { p.bezierCurveTo(bp1x, bp1y, bp2x, bp2y, p2x, p2y); };
function points(opts) {
return (u, seriesIdx, idx0, idx1, filtIdxs) => {
return orient(u, seriesIdx, (series, dataX, dataY, scaleX, scaleY, valToPosX, valToPosY, xOff, yOff, xDim, yDim) => {
let { pxRound, points } = series;
let moveTo, arc;
if (scaleX.ori == 0) {
moveTo = moveToH;
arc = arcH;
}
else {
moveTo = moveToV;
arc = arcV;
}
const width = roundDec(points.width * pxRatio, 3);
let rad = (points.size - points.width) / 2 * pxRatio;
let dia = roundDec(rad * 2, 3);
let fill = new Path2D();
let clip = new Path2D();
let { left: lft, top: top, width: wid, height: hgt } = u.bbox;
rectH(clip,
lft - dia,
top - dia,
wid + dia * 2,
hgt + dia * 2,
);
const drawPoint = pi => {
if (dataY[pi] != null) {
let x = pxRound(valToPosX(dataX[pi], scaleX, xDim, xOff));
let y = pxRound(valToPosY(dataY[pi], scaleY, yDim, yOff));
moveTo(fill, x + rad, y);
arc(fill, x, y, rad, 0, PI * 2);
}
};
if (filtIdxs)
filtIdxs.forEach(drawPoint);
else {
for (let pi = idx0; pi <= idx1; pi++)
drawPoint(pi);
}
return {
stroke: width > 0 ? fill : null,
fill,
clip,
flags: BAND_CLIP_FILL | BAND_CLIP_STROKE,
};
});
};
}
function _drawAcc(lineTo) {
return (stroke, accX, minY, maxY, inY, outY) => {
if (minY != maxY) {
if (inY != minY && outY != minY)
lineTo(stroke, accX, minY);
if (inY != maxY && outY != maxY)
lineTo(stroke, accX, maxY);
lineTo(stroke, accX, outY);
}
};
}
const drawAccH = _drawAcc(lineToH);
const drawAccV = _drawAcc(lineToV);
function linear(opts) {
const alignGaps = ifNull(opts?.alignGaps, 0);
return (u, seriesIdx, idx0, idx1) => {
return orient(u, seriesIdx, (series, dataX, dataY, scaleX, scaleY, valToPosX, valToPosY, xOff, yOff, xDim, yDim) => {
let pxRound = series.pxRound;
let pixelForX = val => pxRound(valToPosX(val, scaleX, xDim, xOff));
let pixelForY = val => pxRound(valToPosY(val, scaleY, yDim, yOff));
let lineTo, drawAcc;
if (scaleX.ori == 0) {
lineTo = lineToH;
drawAcc = drawAccH;
}
else {
lineTo = lineToV;
drawAcc = drawAccV;
}
const dir = scaleX.dir * (scaleX.ori == 0 ? 1 : -1);
const _paths = {stroke: new Path2D(), fill: null, clip: null, band: null, gaps: null, flags: BAND_CLIP_FILL};
const stroke = _paths.stroke;
let minY = inf,
maxY = -inf,
inY, outY, drawnAtX;
let accX = pixelForX(dataX[dir == 1 ? idx0 : idx1]);
let lftIdx = nonNullIdx(dataY, idx0, idx1, 1 * dir);
let rgtIdx = nonNullIdx(dataY, idx0, idx1, -1 * dir);
let lftX = pixelForX(dataX[lftIdx]);
let rgtX = pixelForX(dataX[rgtIdx]);
let hasGap = false;
for (let i = dir == 1 ? idx0 : idx1; i >= idx0 && i <= idx1; i += dir) {
let x = pixelForX(dataX[i]);
let yVal = dataY[i];
if (x == accX) {
if (yVal != null) {
outY = pixelForY(yVal);
if (minY == inf) {
lineTo(stroke, x, outY);
inY = outY;
}
minY = min(outY, minY);
maxY = max(outY, maxY);
}
else {
if (yVal === null)
hasGap = true;
}
}
else {
if (minY != inf) {
drawAcc(stroke, accX, minY, maxY, inY, outY);
drawnAtX = accX;
}
if (yVal != null) {
outY = pixelForY(yVal);
lineTo(stroke, x, outY);
minY = maxY = inY = outY;
}
else {
minY = inf;
maxY = -inf;
if (yVal === null)
hasGap = true;
}
accX = x;
}
}
if (minY != inf && minY != maxY && drawnAtX != accX)
drawAcc(stroke, accX, minY, maxY, inY, outY);
let [ bandFillDir, bandClipDir ] = bandFillClipDirs(u, seriesIdx);
if (series.fill != null || bandFillDir != 0) {
let fill = _paths.fill = new Path2D(stroke);
let fillToVal = series.fillTo(u, seriesIdx, series.min, series.max, bandFillDir);
let fillToY = pixelForY(fillToVal);
lineTo(fill, rgtX, fillToY);
lineTo(fill, lftX, fillToY);
}
if (!series.spanGaps) {
let gaps = [];
hasGap && gaps.push(...findGaps(dataX, dataY, idx0, idx1, dir, pixelForX, alignGaps));
_paths.gaps = gaps = series.gaps(u, seriesIdx, idx0, idx1, gaps);
_paths.clip = clipGaps(gaps, scaleX.ori, xOff, yOff, xDim, yDim);
}
if (bandClipDir != 0) {
_paths.band = bandClipDir == 2 ? [
clipBandLine(u, seriesIdx, idx0, idx1, stroke, -1),
clipBandLine(u, seriesIdx, idx0, idx1, stroke, 1),
] : clipBandLine(u, seriesIdx, idx0, idx1, stroke, bandClipDir);
}
return _paths;
});
};
}
function stepped(opts) {
const align = ifNull(opts.align, 1);
const ascDesc = ifNull(opts.ascDesc, false);
const alignGaps = ifNull(opts.alignGaps, 0);
const extend = ifNull(opts.extend, false);
return (u, seriesIdx, idx0, idx1) => {
return orient(u, seriesIdx, (series, dataX, dataY, scaleX, scaleY, valToPosX, valToPosY, xOff, yOff, xDim, yDim) => {
let pxRound = series.pxRound;
let { left, width } = u.bbox;
let pixelForX = val => pxRound(valToPosX(val, scaleX, xDim, xOff));
let pixelForY = val => pxRound(valToPosY(val, scaleY, yDim, yOff));
let lineTo = scaleX.ori == 0 ? lineToH : lineToV;
const _paths = {stroke: new Path2D(), fill: null, clip: null, band: null, gaps: null, flags: BAND_CLIP_FILL};
const stroke = _paths.stroke;
const dir = scaleX.dir * (scaleX.ori == 0 ? 1 : -1);
idx0 = nonNullIdx(dataY, idx0, idx1, 1);
idx1 = nonNullIdx(dataY, idx0, idx1, -1);
let prevYPos = pixelForY(dataY[dir == 1 ? idx0 : idx1]);
let firstXPos = pixelForX(dataX[dir == 1 ? idx0 : idx1]);
let prevXPos = firstXPos;
let firstXPosExt = firstXPos;
if (extend && align == -1) {
firstXPosExt = left;
lineTo(stroke, firstXPosExt, prevYPos);
}
lineTo(stroke, firstXPos, prevYPos);
for (let i = dir == 1 ? idx0 : idx1; i >= idx0 && i <= idx1; i += dir) {
let yVal1 = dataY[i];
if (yVal1 == null)
continue;
let x1 = pixelForX(dataX[i]);
let y1 = pixelForY(yVal1);
if (align == 1)
lineTo(stroke, x1, prevYPos);
else
lineTo(stroke, prevXPos, y1);
lineTo(stroke, x1, y1);
prevYPos = y1;
prevXPos = x1;
}
let prevXPosExt = prevXPos;
if (extend && align == 1) {
prevXPosExt = left + width;
lineTo(stroke, prevXPosExt, prevYPos);
}
let [ bandFillDir, bandClipDir ] = bandFillClipDirs(u, seriesIdx);
if (series.fill != null || bandFillDir != 0) {
let fill = _paths.fill = new Path2D(stroke);
let fillTo = series.fillTo(u, seriesIdx, series.min, series.max, bandFillDir);
let fillToY = pixelForY(fillTo);
lineTo(fill, prevXPosExt, fillToY);
lineTo(fill, firstXPosExt, fillToY);
}
if (!series.spanGaps) {
let gaps = [];
gaps.push(...findGaps(dataX, dataY, idx0, idx1, dir, pixelForX, alignGaps));
let halfStroke = (series.width * pxRatio) / 2;
let startsOffset = (ascDesc || align == 1) ? halfStroke : -halfStroke;
let endsOffset = (ascDesc || align == -1) ? -halfStroke : halfStroke;
gaps.forEach(g => {
g[0] += startsOffset;
g[1] += endsOffset;
});
_paths.gaps = gaps = series.gaps(u, seriesIdx, idx0, idx1, gaps);
_paths.clip = clipGaps(gaps, scaleX.ori, xOff, yOff, xDim, yDim);
}
if (bandClipDir != 0) {
_paths.band = bandClipDir == 2 ? [
clipBandLine(u, seriesIdx, idx0, idx1, stroke, -1),
clipBandLine(u, seriesIdx, idx0, idx1, stroke, 1),
] : clipBandLine(u, seriesIdx, idx0, idx1, stroke, bandClipDir);
}
return _paths;
});
};
}
function findColWidth(dataX, dataY, valToPosX, scaleX, xDim, xOff, colWid = inf) {
if (dataX.length > 1) {
let prevIdx = null;
for (let i = 0, minDelta = Infinity; i < dataX.length; i++) {
if (dataY[i] !== undefined) {
if (prevIdx != null) {
let delta = abs(dataX[i] - dataX[prevIdx]);
if (delta < minDelta) {
minDelta = delta;
colWid = abs(valToPosX(dataX[i], scaleX, xDim, xOff) - valToPosX(dataX[prevIdx], scaleX, xDim, xOff));
}
}
prevIdx = i;
}
}
}
return colWid;
}
function bars(opts) {
opts = opts || EMPTY_OBJ;
const size = ifNull(opts.size, [0.6, inf, 1]);
const align = opts.align || 0;
const _extraGap = (opts.gap || 0);
let ro = opts.radius;
ro =
ro == null ? [0, 0] :
typeof ro == 'number' ? [ro, 0] : ro;
const radiusFn = fnOrSelf(ro);
const gapFactor = 1 - size[0];
const _maxWidth = ifNull(size[1], inf);
const _minWidth = ifNull(size[2], 1);
const disp = ifNull(opts.disp, EMPTY_OBJ);
const _each = ifNull(opts.each, _ => {});
const { fill: dispFills, stroke: dispStrokes } = disp;
return (u, seriesIdx, idx0, idx1) => {
return orient(u, seriesIdx, (series, dataX, dataY, scaleX, scaleY, valToPosX, valToPosY, xOff, yOff, xDim, yDim) => {
let pxRound = series.pxRound;
let _align = align;
let extraGap = _extraGap * pxRatio;
let maxWidth = _maxWidth * pxRatio;
let minWidth = _minWidth * pxRatio;
let valRadius, baseRadius;
if (scaleX.ori == 0)
[valRadius, baseRadius] = radiusFn(u, seriesIdx);
else
[baseRadius, valRadius] = radiusFn(u, seriesIdx);
const _dirX = scaleX.dir * (scaleX.ori == 0 ? 1 : -1);
let rect = scaleX.ori == 0 ? rectH : rectV;
let each = scaleX.ori == 0 ? _each : (u, seriesIdx, i, top, lft, hgt, wid) => {
_each(u, seriesIdx, i, lft, top, wid, hgt);
};
let band = ifNull(u.bands, EMPTY_ARR).find(b => b.series[0] == seriesIdx);
let fillDir = band != null ? band.dir : 0;
let fillTo = series.fillTo(u, seriesIdx, series.min, series.max, fillDir);
let fillToY = pxRound(valToPosY(fillTo, scaleY, yDim, yOff));
let xShift, barWid, fullGap, colWid = xDim;
let strokeWidth = pxRound(series.width * pxRatio);
let multiPath = false;
let fillColors = null;
let fillPaths = null;
let strokeColors = null;
let strokePaths = null;
if (dispFills != null && (strokeWidth == 0 || dispStrokes != null)) {
multiPath = true;
fillColors = dispFills.values(u, seriesIdx, idx0, idx1);
fillPaths = new Map();
(new Set(fillColors)).forEach(color => {
if (color != null)
fillPaths.set(color, new Path2D());
});
if (strokeWidth > 0) {
strokeColors = dispStrokes.values(u, seriesIdx, idx0, idx1);
strokePaths = new Map();
(new Set(strokeColors)).forEach(color => {
if (color != null)
strokePaths.set(color, new Path2D());
});
}
}
let { x0, size } = disp;
if (x0 != null && size != null) {
_align = 1;
dataX = x0.values(u, seriesIdx, idx0, idx1);
if (x0.unit == 2)
dataX = dataX.map(pct => u.posToVal(xOff + pct * xDim, scaleX.key, true));
let sizes = size.values(u, seriesIdx, idx0, idx1);
if (size.unit == 2)
barWid = sizes[0] * xDim;
else
barWid = valToPosX(sizes[0], scaleX, xDim, xOff) - valToPosX(0, scaleX, xDim, xOff);
colWid = findColWidth(dataX, dataY, valToPosX, scaleX, xDim, xOff, colWid);
let gapWid = colWid - barWid;
fullGap = gapWid + extraGap;
}
else {
colWid = findColWidth(dataX, dataY, valToPosX, scaleX, xDim, xOff, colWid);
let gapWid = colWid * gapFactor;
fullGap = gapWid + extraGap;
barWid = colWid - fullGap;
}
if (fullGap < 1)
fullGap = 0;
if (strokeWidth >= barWid / 2)
strokeWidth = 0;
if (fullGap < 5)
pxRound = retArg0;
let insetStroke = fullGap > 0;
let rawBarWid = colWid - fullGap - (insetStroke ? strokeWidth : 0);
barWid = pxRound(clamp(rawBarWid, minWidth, maxWidth));
xShift = (_align == 0 ? barWid / 2 : _align == _dirX ? 0 : barWid) - _align * _dirX * ((_align == 0 ? extraGap / 2 : 0) + (insetStroke ? strokeWidth / 2 : 0));
const _paths = {stroke: null, fill: null, clip: null, band: null, gaps: null, flags: 0};
const stroke = m