@plotdb/chart 3.9.0 → 3.10.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +20 -0
- package/bundle.js +394 -7
- package/bundle.min.js +1 -1
- package/index.js +12 -4
- package/index.min.js +1 -1
- package/package.json +1 -1
- package/utils/anim.js +3 -3
- package/utils/anim.min.js +1 -1
- package/utils/bin.js +334 -0
- package/utils/bin.min.js +1 -0
- package/utils/config.js +45 -0
- package/utils/config.min.js +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,25 @@
|
|
|
1
1
|
# Change Logs
|
|
2
2
|
|
|
3
|
+
## v3.10.0
|
|
4
|
+
|
|
5
|
+
- bin: `utils.bin` groups raw values into bins ( histogram ), no d3. `edges` / `index` / `range` / `label` /
|
|
6
|
+
`count` are pure; `bin.parse` is called from a chart's `parse` ( `bin.parse.call @, opt` ) - it parses
|
|
7
|
+
`@raw` with the current binding, bins subset rows with the same edges and, with dataframes, computes
|
|
8
|
+
edges from all frames. `bin.filter` / `bin.select` convert between bins and range filters.
|
|
9
|
+
rules: auto width is 1 / 2 / 5 x 10^k ( Sturges for the bin count ), edges at `anchor + k * width`,
|
|
10
|
+
`[a, b)` or `(a, b]`, integer data is treated as discrete ( `10–19`, or `5` with width 1 ).
|
|
11
|
+
- config: add `preset.bin` ( `enabled`, `width`, `count`, `anchor`, `closed`, `label`, `format`, `empty` ).
|
|
12
|
+
charts opt in; `enabled` defaults to false since hosts may auto-bind numeric fields to every R dimension.
|
|
13
|
+
- subset: allow configuring the color that unselected parts fade toward
|
|
14
|
+
via `common.subset.background`. defaults to `cfg.background`, then white.
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
## v3.9.1
|
|
18
|
+
|
|
19
|
+
- anim: check "computed style already at target" before writing immediately, so immediate tweens
|
|
20
|
+
( resize, `document.hidden`, zero duration ) don't leave a redundant inline style like `opacity: 1`.
|
|
21
|
+
|
|
22
|
+
|
|
3
23
|
## v3.9.0
|
|
4
24
|
|
|
5
25
|
- anim: `immediate(v)` - while on, `tween` writes the end value directly ( function values as `v(1)` ).
|
package/bundle.js
CHANGED
|
@@ -1385,6 +1385,10 @@ var module = {exports: {}};
|
|
|
1385
1385
|
min: 0,
|
|
1386
1386
|
max: 1,
|
|
1387
1387
|
step: 0.01
|
|
1388
|
+
},
|
|
1389
|
+
background: {
|
|
1390
|
+
type: 'color',
|
|
1391
|
+
'default': 'transparent'
|
|
1388
1392
|
}
|
|
1389
1393
|
}
|
|
1390
1394
|
}
|
|
@@ -1472,17 +1476,21 @@ var module = {exports: {}};
|
|
|
1472
1476
|
}
|
|
1473
1477
|
},
|
|
1474
1478
|
color: function(color, fade){
|
|
1475
|
-
var rgb, g, f, v;
|
|
1479
|
+
var rgb, g, sub, f, bg, v;
|
|
1476
1480
|
if (!(rgb = _rgb(color))) {
|
|
1477
1481
|
return color;
|
|
1478
1482
|
}
|
|
1479
1483
|
g = 0.3 * rgb[0] + 0.59 * rgb[1] + 0.11 * rgb[2];
|
|
1484
|
+
sub = ((this.cfg || {}).common || {}).subset || {};
|
|
1480
1485
|
f = fade != null
|
|
1481
1486
|
? fade
|
|
1482
|
-
:
|
|
1487
|
+
: sub.fade;
|
|
1483
1488
|
f = f != null ? f : 0.72;
|
|
1484
|
-
|
|
1485
|
-
|
|
1489
|
+
bg = _rgb(sub.background) || _rgb((this.cfg || {}).background) || [255, 255, 255];
|
|
1490
|
+
v = [0, 1, 2].map(function(i){
|
|
1491
|
+
return Math.round(g + (bg[i] - g) * f);
|
|
1492
|
+
});
|
|
1493
|
+
return "rgb(" + v.join(',') + ")";
|
|
1486
1494
|
}
|
|
1487
1495
|
}
|
|
1488
1496
|
};
|
|
@@ -3631,10 +3639,10 @@ var chart = module.exports;
|
|
|
3631
3639
|
delete item.attr[k];
|
|
3632
3640
|
continue;
|
|
3633
3641
|
}
|
|
3634
|
-
if (
|
|
3635
|
-
setV(node, k, typeof v === 'function' ? v(1) : v);
|
|
3642
|
+
if (k.startsWith('style:') && !node.style.getPropertyValue(k.slice(6)) && window.getComputedStyle(node).getPropertyValue(k.slice(6)) === v + "") {
|
|
3636
3643
|
delete item.attr[k];
|
|
3637
|
-
} else if (
|
|
3644
|
+
} else if (immediate) {
|
|
3645
|
+
setV(node, k, typeof v === 'function' ? v(1) : v);
|
|
3638
3646
|
delete item.attr[k];
|
|
3639
3647
|
} else if (typeof v === 'function') {
|
|
3640
3648
|
item.attr[k] = {
|
|
@@ -4634,6 +4642,51 @@ var chart = module.exports;
|
|
|
4634
4642
|
'default': false
|
|
4635
4643
|
}
|
|
4636
4644
|
},
|
|
4645
|
+
bin: {
|
|
4646
|
+
enabled: {
|
|
4647
|
+
type: 'boolean',
|
|
4648
|
+
'default': false
|
|
4649
|
+
},
|
|
4650
|
+
width: {
|
|
4651
|
+
type: 'number',
|
|
4652
|
+
'default': 0,
|
|
4653
|
+
min: 0,
|
|
4654
|
+
max: 1000000,
|
|
4655
|
+
step: 0.01
|
|
4656
|
+
},
|
|
4657
|
+
count: {
|
|
4658
|
+
type: 'number',
|
|
4659
|
+
'default': 0,
|
|
4660
|
+
min: 0,
|
|
4661
|
+
max: 100,
|
|
4662
|
+
step: 1
|
|
4663
|
+
},
|
|
4664
|
+
anchor: {
|
|
4665
|
+
type: 'number',
|
|
4666
|
+
'default': 0,
|
|
4667
|
+
min: -1000000,
|
|
4668
|
+
max: 1000000,
|
|
4669
|
+
step: 0.01
|
|
4670
|
+
},
|
|
4671
|
+
closed: {
|
|
4672
|
+
type: 'choice',
|
|
4673
|
+
values: ['left', 'right'],
|
|
4674
|
+
'default': 'left'
|
|
4675
|
+
},
|
|
4676
|
+
label: {
|
|
4677
|
+
type: 'choice',
|
|
4678
|
+
values: ['range', 'start', 'center'],
|
|
4679
|
+
'default': 'range'
|
|
4680
|
+
},
|
|
4681
|
+
format: {
|
|
4682
|
+
type: 'format',
|
|
4683
|
+
'default': ''
|
|
4684
|
+
},
|
|
4685
|
+
empty: {
|
|
4686
|
+
type: 'boolean',
|
|
4687
|
+
'default': true
|
|
4688
|
+
}
|
|
4689
|
+
},
|
|
4637
4690
|
axis: {
|
|
4638
4691
|
enabled: {
|
|
4639
4692
|
type: 'boolean',
|
|
@@ -6182,6 +6235,340 @@ var chart = module.exports;
|
|
|
6182
6235
|
(chart.utils || (chart.utils = {})).tip = tip;
|
|
6183
6236
|
}
|
|
6184
6237
|
}).call(this);
|
|
6238
|
+
(function(){
|
|
6239
|
+
var eps, clean, isInt, niceStep, autoWidth, rawIndex, bin;
|
|
6240
|
+
eps = 1e-9;
|
|
6241
|
+
clean = function(v){
|
|
6242
|
+
return +(+v).toPrecision(12);
|
|
6243
|
+
};
|
|
6244
|
+
isInt = function(v){
|
|
6245
|
+
return Math.abs(v - Math.round(v)) < eps;
|
|
6246
|
+
};
|
|
6247
|
+
niceStep = function(span, count){
|
|
6248
|
+
var raw, p, e, m;
|
|
6249
|
+
raw = span / (count > 1 ? count : 1);
|
|
6250
|
+
if (!(raw > 0)) {
|
|
6251
|
+
return 1;
|
|
6252
|
+
}
|
|
6253
|
+
p = Math.pow(10, Math.floor(Math.log10(raw)));
|
|
6254
|
+
e = raw / p;
|
|
6255
|
+
m = e >= Math.sqrt(50)
|
|
6256
|
+
? 10
|
|
6257
|
+
: e >= Math.sqrt(10)
|
|
6258
|
+
? 5
|
|
6259
|
+
: e >= Math.sqrt(2) ? 2 : 1;
|
|
6260
|
+
return clean(m * p);
|
|
6261
|
+
};
|
|
6262
|
+
autoWidth = function(vs, lo, hi, opt){
|
|
6263
|
+
var count, ref$, span, w;
|
|
6264
|
+
count = opt.count > 0
|
|
6265
|
+
? opt.count
|
|
6266
|
+
: Math.ceil(Math.log2((ref$ = vs.length) > 1 ? ref$ : 1)) + 1;
|
|
6267
|
+
if (hi === lo && isInt(lo)) {
|
|
6268
|
+
return 1;
|
|
6269
|
+
}
|
|
6270
|
+
span = hi > lo
|
|
6271
|
+
? hi - lo
|
|
6272
|
+
: Math.abs(lo) || 1;
|
|
6273
|
+
w = niceStep(span, count);
|
|
6274
|
+
if (vs.every(isInt) && w < 1) {
|
|
6275
|
+
w = 1;
|
|
6276
|
+
}
|
|
6277
|
+
return w;
|
|
6278
|
+
};
|
|
6279
|
+
rawIndex = function(v, info){
|
|
6280
|
+
var k;
|
|
6281
|
+
k = (v - info.start) / info.width;
|
|
6282
|
+
if (Math.abs(k - Math.round(k)) < eps) {
|
|
6283
|
+
k = Math.round(k);
|
|
6284
|
+
}
|
|
6285
|
+
if (info.closed === 'right') {
|
|
6286
|
+
return Math.ceil(k) - 1;
|
|
6287
|
+
} else {
|
|
6288
|
+
return Math.floor(k);
|
|
6289
|
+
}
|
|
6290
|
+
};
|
|
6291
|
+
bin = {
|
|
6292
|
+
edges: function(values, opt){
|
|
6293
|
+
var vs, closed, anchor, max, ref$, lo, hi, width, discrete, info, k, last, res$, i$, to$, i;
|
|
6294
|
+
values == null && (values = []);
|
|
6295
|
+
opt == null && (opt = {});
|
|
6296
|
+
vs = values.filter(function(it){
|
|
6297
|
+
return typeof it === 'number' && isFinite(it);
|
|
6298
|
+
});
|
|
6299
|
+
closed = opt.closed === 'right' ? 'right' : 'left';
|
|
6300
|
+
anchor = isFinite(+opt.anchor) ? +opt.anchor : 0;
|
|
6301
|
+
max = opt.max || 500;
|
|
6302
|
+
if (!vs.length) {
|
|
6303
|
+
return {
|
|
6304
|
+
start: anchor,
|
|
6305
|
+
width: +opt.width || 1,
|
|
6306
|
+
anchor: anchor,
|
|
6307
|
+
closed: closed,
|
|
6308
|
+
discrete: false,
|
|
6309
|
+
n: 0,
|
|
6310
|
+
edges: []
|
|
6311
|
+
};
|
|
6312
|
+
}
|
|
6313
|
+
ref$ = [Math.min.apply(Math, vs), Math.max.apply(Math, vs)], lo = ref$[0], hi = ref$[1];
|
|
6314
|
+
width = +opt.width > 0
|
|
6315
|
+
? +opt.width
|
|
6316
|
+
: autoWidth(vs, lo, hi, opt);
|
|
6317
|
+
if ((hi - lo) / width > max) {
|
|
6318
|
+
width = autoWidth(vs, lo, hi, {
|
|
6319
|
+
count: opt.count
|
|
6320
|
+
});
|
|
6321
|
+
}
|
|
6322
|
+
discrete = isInt(width) && isInt(anchor) && vs.every(isInt);
|
|
6323
|
+
info = {
|
|
6324
|
+
width: width,
|
|
6325
|
+
anchor: anchor,
|
|
6326
|
+
closed: closed,
|
|
6327
|
+
discrete: discrete
|
|
6328
|
+
};
|
|
6329
|
+
k = (lo - anchor) / width;
|
|
6330
|
+
if (Math.abs(k - Math.round(k)) < eps) {
|
|
6331
|
+
k = Math.round(k);
|
|
6332
|
+
}
|
|
6333
|
+
info.start = clean(anchor + width * (closed === 'left'
|
|
6334
|
+
? Math.floor(k)
|
|
6335
|
+
: !discrete && isInt(k)
|
|
6336
|
+
? k
|
|
6337
|
+
: Math.ceil(k) - 1));
|
|
6338
|
+
last = rawIndex(hi, info);
|
|
6339
|
+
if (!discrete && closed === 'left' && last > 0 && isInt((hi - info.start) / width)) {
|
|
6340
|
+
last = last - 1;
|
|
6341
|
+
}
|
|
6342
|
+
info.n = (ref$ = last + 1) > 1 ? ref$ : 1;
|
|
6343
|
+
res$ = [];
|
|
6344
|
+
for (i$ = 0, to$ = info.n; i$ <= to$; ++i$) {
|
|
6345
|
+
i = i$;
|
|
6346
|
+
res$.push(clean(info.start + width * i));
|
|
6347
|
+
}
|
|
6348
|
+
info.edges = res$;
|
|
6349
|
+
return info;
|
|
6350
|
+
},
|
|
6351
|
+
index: function(v, info){
|
|
6352
|
+
var i;
|
|
6353
|
+
if (!(typeof v === 'number' && isFinite(v)) || !info.n) {
|
|
6354
|
+
return -1;
|
|
6355
|
+
}
|
|
6356
|
+
i = rawIndex(v, info);
|
|
6357
|
+
if (!info.discrete) {
|
|
6358
|
+
if (i === info.n && info.closed === 'left' && Math.abs(v - info.edges[info.n]) < eps * info.width) {
|
|
6359
|
+
i = info.n - 1;
|
|
6360
|
+
}
|
|
6361
|
+
if (i === -1 && info.closed === 'right' && Math.abs(v - info.edges[0]) < eps * info.width) {
|
|
6362
|
+
i = 0;
|
|
6363
|
+
}
|
|
6364
|
+
}
|
|
6365
|
+
if (i < 0 || i >= info.n) {
|
|
6366
|
+
return -1;
|
|
6367
|
+
} else {
|
|
6368
|
+
return i;
|
|
6369
|
+
}
|
|
6370
|
+
},
|
|
6371
|
+
range: function(i, info){
|
|
6372
|
+
var ref$, a, b;
|
|
6373
|
+
ref$ = [info.edges[i], info.edges[i + 1]], a = ref$[0], b = ref$[1];
|
|
6374
|
+
if (!info.discrete) {
|
|
6375
|
+
return [a, b];
|
|
6376
|
+
}
|
|
6377
|
+
if (info.closed === 'right') {
|
|
6378
|
+
return [clean(a + 1), b];
|
|
6379
|
+
} else {
|
|
6380
|
+
return [a, clean(b - 1)];
|
|
6381
|
+
}
|
|
6382
|
+
},
|
|
6383
|
+
label: function(i, info, opt){
|
|
6384
|
+
var f, ref$, ref1$, a, b;
|
|
6385
|
+
opt == null && (opt = {});
|
|
6386
|
+
f = opt.format && ((typeof chart != 'undefined' && chart !== null) && ((ref$ = chart.utils) != null && ref$.format))
|
|
6387
|
+
? chart.utils.format.from(opt.format)
|
|
6388
|
+
: function(it){
|
|
6389
|
+
return clean(it) + "";
|
|
6390
|
+
};
|
|
6391
|
+
ref1$ = bin.range(i, info), a = ref1$[0], b = ref1$[1];
|
|
6392
|
+
switch (opt.label) {
|
|
6393
|
+
case 'start':
|
|
6394
|
+
return f(a);
|
|
6395
|
+
case 'center':
|
|
6396
|
+
return f(clean((info.edges[i] + info.edges[i + 1]) / 2));
|
|
6397
|
+
default:
|
|
6398
|
+
if (a === b) {
|
|
6399
|
+
return f(a);
|
|
6400
|
+
} else {
|
|
6401
|
+
return f(a) + "–" + f(b);
|
|
6402
|
+
}
|
|
6403
|
+
}
|
|
6404
|
+
},
|
|
6405
|
+
count: function(values, info, weights){
|
|
6406
|
+
var m, ref$, ret, res$, i$, to$, i, len$, j, v, j$, k, w;
|
|
6407
|
+
values == null && (values = []);
|
|
6408
|
+
m = weights ? (ref$ = (weights[0] || []).length) > 1 ? ref$ : 1 : 1;
|
|
6409
|
+
res$ = [];
|
|
6410
|
+
for (i$ = 0, to$ = info.n; i$ < to$; ++i$) {
|
|
6411
|
+
i = i$;
|
|
6412
|
+
res$.push(repeatArray$([0], m));
|
|
6413
|
+
}
|
|
6414
|
+
ret = res$;
|
|
6415
|
+
for (i$ = 0, len$ = values.length; i$ < len$; ++i$) {
|
|
6416
|
+
j = i$;
|
|
6417
|
+
v = values[i$];
|
|
6418
|
+
if ((i = bin.index(v, info)) < 0) {
|
|
6419
|
+
continue;
|
|
6420
|
+
}
|
|
6421
|
+
if (!weights) {
|
|
6422
|
+
ret[i][0] += 1;
|
|
6423
|
+
continue;
|
|
6424
|
+
}
|
|
6425
|
+
for (j$ = 0; j$ < m; ++j$) {
|
|
6426
|
+
k = j$;
|
|
6427
|
+
w = +(weights[j] || [])[k];
|
|
6428
|
+
if (isFinite(w)) {
|
|
6429
|
+
ret[i][k] += w;
|
|
6430
|
+
}
|
|
6431
|
+
}
|
|
6432
|
+
}
|
|
6433
|
+
return ret;
|
|
6434
|
+
},
|
|
6435
|
+
parse: function(opt){
|
|
6436
|
+
var ref$, kv, ks, kn, cfg, sb, series, rows, all, info, vals, wts, counts, sub, shrink, labels, res$, i$, to$, i, data, d, ref1$, x0, x1;
|
|
6437
|
+
opt == null && (opt = {});
|
|
6438
|
+
ref$ = [opt.value || 'value', opt.size || 'size', opt.name || 'name'], kv = ref$[0], ks = ref$[1], kn = ref$[2];
|
|
6439
|
+
cfg = opt.config || (this.cfg || {}).bin || {};
|
|
6440
|
+
sb = this.binding[ks];
|
|
6441
|
+
series = !sb
|
|
6442
|
+
? 0
|
|
6443
|
+
: Array.isArray(sb) ? sb.length : 1;
|
|
6444
|
+
rows = this._parseRows(this.raw || []);
|
|
6445
|
+
all = this._frames && ((typeof chart != 'undefined' && chart !== null) && ((ref$ = chart.scopes) != null && ref$.frame)) ? chart.scopes.frame.all.call(this) : rows;
|
|
6446
|
+
info = bin.edges(all.map(function(it){
|
|
6447
|
+
return it[kv];
|
|
6448
|
+
}), cfg);
|
|
6449
|
+
vals = function(rs){
|
|
6450
|
+
return rs.map(function(it){
|
|
6451
|
+
return it[kv];
|
|
6452
|
+
});
|
|
6453
|
+
};
|
|
6454
|
+
wts = function(rs){
|
|
6455
|
+
if (!series) {
|
|
6456
|
+
return null;
|
|
6457
|
+
} else {
|
|
6458
|
+
return rs.map(function(it){
|
|
6459
|
+
return [].concat(it[ks]);
|
|
6460
|
+
});
|
|
6461
|
+
}
|
|
6462
|
+
};
|
|
6463
|
+
counts = bin.count(vals(rows), info, wts(rows));
|
|
6464
|
+
sub = !this._subset
|
|
6465
|
+
? null
|
|
6466
|
+
: bin.count(vals(this._parseRows(this._subset)), info, wts(this._parseRows(this._subset)));
|
|
6467
|
+
shrink = (((this.cfg || {}).common || {}).subset || {}).mode === 'shrink';
|
|
6468
|
+
res$ = [];
|
|
6469
|
+
for (i$ = 0, to$ = info.n; i$ < to$; ++i$) {
|
|
6470
|
+
i = i$;
|
|
6471
|
+
res$.push(bin.label(i, info, cfg));
|
|
6472
|
+
}
|
|
6473
|
+
labels = res$;
|
|
6474
|
+
if (new Set(labels).size !== labels.length) {
|
|
6475
|
+
res$ = [];
|
|
6476
|
+
for (i$ = 0, to$ = info.n; i$ < to$; ++i$) {
|
|
6477
|
+
i = i$;
|
|
6478
|
+
res$.push(bin.label(i, info, {
|
|
6479
|
+
label: cfg.label
|
|
6480
|
+
}));
|
|
6481
|
+
}
|
|
6482
|
+
labels = res$;
|
|
6483
|
+
}
|
|
6484
|
+
data = [];
|
|
6485
|
+
for (i$ = 0, to$ = info.n; i$ < to$; ++i$) {
|
|
6486
|
+
i = i$;
|
|
6487
|
+
if (cfg.empty === false && counts[i].every(fn$)) {
|
|
6488
|
+
continue;
|
|
6489
|
+
}
|
|
6490
|
+
d = {};
|
|
6491
|
+
d[kn] = labels[i];
|
|
6492
|
+
d[ks] = counts[i];
|
|
6493
|
+
ref1$ = [info.edges[i], info.edges[i + 1]], x0 = ref1$[0], x1 = ref1$[1];
|
|
6494
|
+
d.bin = {
|
|
6495
|
+
x0: x0,
|
|
6496
|
+
x1: x1,
|
|
6497
|
+
index: i
|
|
6498
|
+
};
|
|
6499
|
+
if (sub) {
|
|
6500
|
+
d.subset = {};
|
|
6501
|
+
d.subset[ks] = sub[i];
|
|
6502
|
+
if (shrink) {
|
|
6503
|
+
d[ks] = sub[i];
|
|
6504
|
+
}
|
|
6505
|
+
}
|
|
6506
|
+
d._idx = data.length;
|
|
6507
|
+
d._raw = (ref1$ = import$({}, d.bin), ref1$.count = counts[i], ref1$);
|
|
6508
|
+
data.push(d);
|
|
6509
|
+
}
|
|
6510
|
+
return {
|
|
6511
|
+
data: data,
|
|
6512
|
+
info: info,
|
|
6513
|
+
series: series || 1
|
|
6514
|
+
};
|
|
6515
|
+
function fn$(it){
|
|
6516
|
+
return !it;
|
|
6517
|
+
}
|
|
6518
|
+
},
|
|
6519
|
+
filter: function(a, b, info){
|
|
6520
|
+
var ref$, x0, x1, closed;
|
|
6521
|
+
ref$ = [info.edges[a], info.edges[b + 1]], x0 = ref$[0], x1 = ref$[1];
|
|
6522
|
+
closed = info.closed;
|
|
6523
|
+
if (!info.discrete) {
|
|
6524
|
+
if (closed === 'left' && b === info.n - 1) {
|
|
6525
|
+
closed = 'both';
|
|
6526
|
+
}
|
|
6527
|
+
if (closed === 'right' && a === 0) {
|
|
6528
|
+
closed = 'both';
|
|
6529
|
+
}
|
|
6530
|
+
}
|
|
6531
|
+
return {
|
|
6532
|
+
type: 'range',
|
|
6533
|
+
value: [x0, x1],
|
|
6534
|
+
closed: closed
|
|
6535
|
+
};
|
|
6536
|
+
},
|
|
6537
|
+
select: function(f, info){
|
|
6538
|
+
var ref$, lo, hi, idx, res$, i$, to$, i;
|
|
6539
|
+
if (!(f && f.type === 'range' && Array.isArray(f.value)) || !info.n) {
|
|
6540
|
+
return null;
|
|
6541
|
+
}
|
|
6542
|
+
ref$ = f.value, lo = ref$[0], hi = ref$[1];
|
|
6543
|
+
res$ = [];
|
|
6544
|
+
for (i$ = 0, to$ = info.n; i$ < to$; ++i$) {
|
|
6545
|
+
i = i$;
|
|
6546
|
+
if (info.edges[i + 1] > lo && info.edges[i] < hi) {
|
|
6547
|
+
res$.push(i);
|
|
6548
|
+
}
|
|
6549
|
+
}
|
|
6550
|
+
idx = res$;
|
|
6551
|
+
if (!idx.length) {
|
|
6552
|
+
return null;
|
|
6553
|
+
} else {
|
|
6554
|
+
return [idx[0], idx[idx.length - 1]];
|
|
6555
|
+
}
|
|
6556
|
+
}
|
|
6557
|
+
};
|
|
6558
|
+
if (typeof chart != 'undefined' && chart !== null) {
|
|
6559
|
+
(chart.utils || (chart.utils = {})).bin = bin;
|
|
6560
|
+
}
|
|
6561
|
+
function repeatArray$(arr, n){
|
|
6562
|
+
for (var r = []; n > 0; (n >>= 1) && (arr = arr.concat(arr)))
|
|
6563
|
+
if (n & 1) r.push.apply(r, arr);
|
|
6564
|
+
return r;
|
|
6565
|
+
}
|
|
6566
|
+
function import$(obj, src){
|
|
6567
|
+
var own = {}.hasOwnProperty;
|
|
6568
|
+
for (var key in src) if (own.call(src, key)) obj[key] = src[key];
|
|
6569
|
+
return obj;
|
|
6570
|
+
}
|
|
6571
|
+
}).call(this);
|
|
6185
6572
|
chart.utils.debounce = debounce;
|
|
6186
6573
|
if (typeof window != 'undefined' && window !== null) { window.chart = chart; }
|
|
6187
6574
|
})();
|