d3-rails 4.7.4 → 4.8.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHANGELOG.md +3 -0
- data/README.md +1 -1
- data/app/assets/javascripts/d3.js +229 -117
- data/app/assets/javascripts/d3.min.js +8 -8
- data/app/assets/javascripts/d3.v4.js +229 -117
- data/app/assets/javascripts/d3.v4.min.js +8 -8
- data/lib/d3/rails/version.rb +1 -1
- metadata +2 -2
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA1:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: 24f20f9493fba5c1f8305d14092ba0b8b690dec5
|
4
|
+
data.tar.gz: 8119c2d1696efb04885477fcd07f55b745fafb19
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: 1519b56b9e8de820a076c26f553736a4819d78610049cba2f20ddab0a6ec9c2068884014941b44ae9a89bfe8714d5caee592890baedb287aa9f5f94deb29eb16
|
7
|
+
data.tar.gz: e9ac4beb4b6399240df5d0939b1740c7d9d03593780e855e456329c2b74d5a074983ed7940790b63f04601203e06a442990fd700fad7a5dc21ff39bb30e04d4e
|
data/CHANGELOG.md
CHANGED
data/README.md
CHANGED
@@ -8,7 +8,7 @@ d3-rails provides D3 for Rails 3.1 and higher.
|
|
8
8
|
|
9
9
|
## Version
|
10
10
|
|
11
|
-
d3-rails comes with version 4.
|
11
|
+
d3-rails comes with version 4.8.0 of D3.js. The d3-rails version will
|
12
12
|
always mirror the version of D3. If you need a newer version of
|
13
13
|
d3-rails, see section Development (below).
|
14
14
|
|
@@ -1,11 +1,11 @@
|
|
1
|
-
// https://d3js.org Version 4.
|
1
|
+
// https://d3js.org Version 4.8.0. Copyright 2017 Mike Bostock.
|
2
2
|
(function (global, factory) {
|
3
3
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
4
4
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
5
5
|
(factory((global.d3 = global.d3 || {})));
|
6
6
|
}(this, (function (exports) { 'use strict';
|
7
7
|
|
8
|
-
var version = "4.
|
8
|
+
var version = "4.8.0";
|
9
9
|
|
10
10
|
var ascending = function(a, b) {
|
11
11
|
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
@@ -58,11 +58,24 @@ function pair(a, b) {
|
|
58
58
|
return [a, b];
|
59
59
|
}
|
60
60
|
|
61
|
-
var cross = function(
|
62
|
-
var
|
63
|
-
|
64
|
-
|
65
|
-
|
61
|
+
var cross = function(values0, values1, reduce) {
|
62
|
+
var n0 = values0.length,
|
63
|
+
n1 = values1.length,
|
64
|
+
values = new Array(n0 * n1),
|
65
|
+
i0,
|
66
|
+
i1,
|
67
|
+
i,
|
68
|
+
value0;
|
69
|
+
|
70
|
+
if (reduce == null) reduce = pair;
|
71
|
+
|
72
|
+
for (i0 = i = 0; i0 < n0; ++i0) {
|
73
|
+
for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {
|
74
|
+
values[i] = reduce(value0, values1[i1]);
|
75
|
+
}
|
76
|
+
}
|
77
|
+
|
78
|
+
return values;
|
66
79
|
};
|
67
80
|
|
68
81
|
var descending = function(a, b) {
|
@@ -73,36 +86,36 @@ var number = function(x) {
|
|
73
86
|
return x === null ? NaN : +x;
|
74
87
|
};
|
75
88
|
|
76
|
-
var variance = function(
|
77
|
-
var n =
|
89
|
+
var variance = function(values, valueof) {
|
90
|
+
var n = values.length,
|
78
91
|
m = 0,
|
79
|
-
a,
|
80
|
-
d,
|
81
|
-
s = 0,
|
82
92
|
i = -1,
|
83
|
-
|
93
|
+
mean = 0,
|
94
|
+
value,
|
95
|
+
delta,
|
96
|
+
sum = 0;
|
84
97
|
|
85
|
-
if (
|
98
|
+
if (valueof == null) {
|
86
99
|
while (++i < n) {
|
87
|
-
if (!isNaN(
|
88
|
-
|
89
|
-
|
90
|
-
|
100
|
+
if (!isNaN(value = number(values[i]))) {
|
101
|
+
delta = value - mean;
|
102
|
+
mean += delta / ++m;
|
103
|
+
sum += delta * (value - mean);
|
91
104
|
}
|
92
105
|
}
|
93
106
|
}
|
94
107
|
|
95
108
|
else {
|
96
109
|
while (++i < n) {
|
97
|
-
if (!isNaN(
|
98
|
-
|
99
|
-
|
100
|
-
|
110
|
+
if (!isNaN(value = number(valueof(values[i], i, values)))) {
|
111
|
+
delta = value - mean;
|
112
|
+
mean += delta / ++m;
|
113
|
+
sum += delta * (value - mean);
|
101
114
|
}
|
102
115
|
}
|
103
116
|
}
|
104
117
|
|
105
|
-
if (
|
118
|
+
if (m > 1) return sum / (m - 1);
|
106
119
|
};
|
107
120
|
|
108
121
|
var deviation = function(array, f) {
|
@@ -110,30 +123,42 @@ var deviation = function(array, f) {
|
|
110
123
|
return v ? Math.sqrt(v) : v;
|
111
124
|
};
|
112
125
|
|
113
|
-
var extent = function(
|
114
|
-
var
|
115
|
-
|
116
|
-
|
117
|
-
|
118
|
-
|
119
|
-
|
120
|
-
if (
|
121
|
-
while (++i < n)
|
122
|
-
|
123
|
-
|
124
|
-
|
126
|
+
var extent = function(values, valueof) {
|
127
|
+
var n = values.length,
|
128
|
+
i = -1,
|
129
|
+
value,
|
130
|
+
min,
|
131
|
+
max;
|
132
|
+
|
133
|
+
if (valueof == null) {
|
134
|
+
while (++i < n) { // Find the first comparable value.
|
135
|
+
if ((value = values[i]) != null && value >= value) {
|
136
|
+
min = max = value;
|
137
|
+
while (++i < n) { // Compare the remaining values.
|
138
|
+
if ((value = values[i]) != null) {
|
139
|
+
if (min > value) min = value;
|
140
|
+
if (max < value) max = value;
|
141
|
+
}
|
142
|
+
}
|
143
|
+
}
|
125
144
|
}
|
126
145
|
}
|
127
146
|
|
128
147
|
else {
|
129
|
-
while (++i < n)
|
130
|
-
|
131
|
-
|
132
|
-
|
148
|
+
while (++i < n) { // Find the first comparable value.
|
149
|
+
if ((value = valueof(values[i], i, values)) != null && value >= value) {
|
150
|
+
min = max = value;
|
151
|
+
while (++i < n) { // Compare the remaining values.
|
152
|
+
if ((value = valueof(values[i], i, values)) != null) {
|
153
|
+
if (min > value) min = value;
|
154
|
+
if (max < value) max = value;
|
155
|
+
}
|
156
|
+
}
|
157
|
+
}
|
133
158
|
}
|
134
159
|
}
|
135
160
|
|
136
|
-
return [
|
161
|
+
return [min, max];
|
137
162
|
};
|
138
163
|
|
139
164
|
var array = Array.prototype;
|
@@ -170,14 +195,42 @@ var e5 = Math.sqrt(10);
|
|
170
195
|
var e2 = Math.sqrt(2);
|
171
196
|
|
172
197
|
var ticks = function(start, stop, count) {
|
173
|
-
var
|
174
|
-
|
175
|
-
|
176
|
-
|
177
|
-
|
178
|
-
|
198
|
+
var reverse = stop < start,
|
199
|
+
i = -1,
|
200
|
+
n,
|
201
|
+
ticks,
|
202
|
+
step;
|
203
|
+
|
204
|
+
if (reverse) n = start, start = stop, stop = n;
|
205
|
+
|
206
|
+
if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
|
207
|
+
|
208
|
+
if (step > 0) {
|
209
|
+
start = Math.ceil(start / step);
|
210
|
+
stop = Math.floor(stop / step);
|
211
|
+
ticks = new Array(n = Math.ceil(stop - start + 1));
|
212
|
+
while (++i < n) ticks[i] = (start + i) * step;
|
213
|
+
} else {
|
214
|
+
start = Math.floor(start * step);
|
215
|
+
stop = Math.ceil(stop * step);
|
216
|
+
ticks = new Array(n = Math.ceil(start - stop + 1));
|
217
|
+
while (++i < n) ticks[i] = (start - i) / step;
|
218
|
+
}
|
219
|
+
|
220
|
+
if (reverse) ticks.reverse();
|
221
|
+
|
222
|
+
return ticks;
|
179
223
|
};
|
180
224
|
|
225
|
+
function tickIncrement(start, stop, count) {
|
226
|
+
var step = (stop - start) / Math.max(0, count),
|
227
|
+
power = Math.floor(Math.log(step) / Math.LN10),
|
228
|
+
error = step / Math.pow(10, power);
|
229
|
+
return power >= 0
|
230
|
+
? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
|
231
|
+
: -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
|
232
|
+
}
|
233
|
+
|
181
234
|
function tickStep(start, stop, count) {
|
182
235
|
var step0 = Math.abs(stop - start) / Math.max(0, count),
|
183
236
|
step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
|
@@ -213,12 +266,15 @@ var histogram = function() {
|
|
213
266
|
tz = threshold(values, x0, x1);
|
214
267
|
|
215
268
|
// Convert number of thresholds into uniform thresholds.
|
216
|
-
if (!Array.isArray(tz))
|
269
|
+
if (!Array.isArray(tz)) {
|
270
|
+
tz = tickStep(x0, x1, tz);
|
271
|
+
tz = sequence(Math.ceil(x0 / tz) * tz, Math.floor(x1 / tz) * tz, tz); // exclusive
|
272
|
+
}
|
217
273
|
|
218
274
|
// Remove any thresholds outside the domain.
|
219
275
|
var m = tz.length;
|
220
276
|
while (tz[0] <= x0) tz.shift(), --m;
|
221
|
-
while (tz[m - 1]
|
277
|
+
while (tz[m - 1] > x1) tz.pop(), --m;
|
222
278
|
|
223
279
|
var bins = new Array(m + 1),
|
224
280
|
bin;
|
@@ -256,17 +312,17 @@ var histogram = function() {
|
|
256
312
|
return histogram;
|
257
313
|
};
|
258
314
|
|
259
|
-
var threshold = function(
|
260
|
-
if (
|
261
|
-
if (!(n =
|
262
|
-
if ((p = +p) <= 0 || n < 2) return +
|
263
|
-
if (p >= 1) return +
|
315
|
+
var threshold = function(values, p, valueof) {
|
316
|
+
if (valueof == null) valueof = number;
|
317
|
+
if (!(n = values.length)) return;
|
318
|
+
if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
|
319
|
+
if (p >= 1) return +valueof(values[n - 1], n - 1, values);
|
264
320
|
var n,
|
265
|
-
|
266
|
-
|
267
|
-
|
268
|
-
|
269
|
-
return
|
321
|
+
i = (n - 1) * p,
|
322
|
+
i0 = Math.floor(i),
|
323
|
+
value0 = +valueof(values[i0], i0, values),
|
324
|
+
value1 = +valueof(values[i0 + 1], i0 + 1, values);
|
325
|
+
return value0 + (value1 - value0) * (i - i0);
|
270
326
|
};
|
271
327
|
|
272
328
|
var freedmanDiaconis = function(values, min, max) {
|
@@ -278,55 +334,85 @@ var scott = function(values, min, max) {
|
|
278
334
|
return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
|
279
335
|
};
|
280
336
|
|
281
|
-
var max = function(
|
282
|
-
var
|
283
|
-
|
284
|
-
|
285
|
-
|
286
|
-
|
287
|
-
if (
|
288
|
-
while (++i < n)
|
289
|
-
|
337
|
+
var max = function(values, valueof) {
|
338
|
+
var n = values.length,
|
339
|
+
i = -1,
|
340
|
+
value,
|
341
|
+
max;
|
342
|
+
|
343
|
+
if (valueof == null) {
|
344
|
+
while (++i < n) { // Find the first comparable value.
|
345
|
+
if ((value = values[i]) != null && value >= value) {
|
346
|
+
max = value;
|
347
|
+
while (++i < n) { // Compare the remaining values.
|
348
|
+
if ((value = values[i]) != null && value > max) {
|
349
|
+
max = value;
|
350
|
+
}
|
351
|
+
}
|
352
|
+
}
|
353
|
+
}
|
290
354
|
}
|
291
355
|
|
292
356
|
else {
|
293
|
-
while (++i < n)
|
294
|
-
|
357
|
+
while (++i < n) { // Find the first comparable value.
|
358
|
+
if ((value = valueof(values[i], i, values)) != null && value >= value) {
|
359
|
+
max = value;
|
360
|
+
while (++i < n) { // Compare the remaining values.
|
361
|
+
if ((value = valueof(values[i], i, values)) != null && value > max) {
|
362
|
+
max = value;
|
363
|
+
}
|
364
|
+
}
|
365
|
+
}
|
366
|
+
}
|
295
367
|
}
|
296
368
|
|
297
|
-
return
|
369
|
+
return max;
|
298
370
|
};
|
299
371
|
|
300
|
-
var mean = function(
|
301
|
-
var
|
302
|
-
|
303
|
-
a,
|
372
|
+
var mean = function(values, valueof) {
|
373
|
+
var n = values.length,
|
374
|
+
m = n,
|
304
375
|
i = -1,
|
305
|
-
|
376
|
+
value,
|
377
|
+
sum = 0;
|
306
378
|
|
307
|
-
if (
|
308
|
-
while (++i < n)
|
379
|
+
if (valueof == null) {
|
380
|
+
while (++i < n) {
|
381
|
+
if (!isNaN(value = number(values[i]))) sum += value;
|
382
|
+
else --m;
|
383
|
+
}
|
309
384
|
}
|
310
385
|
|
311
386
|
else {
|
312
|
-
while (++i < n)
|
387
|
+
while (++i < n) {
|
388
|
+
if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
|
389
|
+
else --m;
|
390
|
+
}
|
313
391
|
}
|
314
392
|
|
315
|
-
if (
|
393
|
+
if (m) return sum / m;
|
316
394
|
};
|
317
395
|
|
318
|
-
var median = function(
|
319
|
-
var
|
320
|
-
|
321
|
-
|
322
|
-
|
396
|
+
var median = function(values, valueof) {
|
397
|
+
var n = values.length,
|
398
|
+
i = -1,
|
399
|
+
value,
|
400
|
+
numbers = [];
|
323
401
|
|
324
|
-
if (
|
325
|
-
while (++i < n)
|
402
|
+
if (valueof == null) {
|
403
|
+
while (++i < n) {
|
404
|
+
if (!isNaN(value = number(values[i]))) {
|
405
|
+
numbers.push(value);
|
406
|
+
}
|
407
|
+
}
|
326
408
|
}
|
327
409
|
|
328
410
|
else {
|
329
|
-
while (++i < n)
|
411
|
+
while (++i < n) {
|
412
|
+
if (!isNaN(value = number(valueof(values[i], i, values)))) {
|
413
|
+
numbers.push(value);
|
414
|
+
}
|
415
|
+
}
|
330
416
|
}
|
331
417
|
|
332
418
|
return threshold(numbers.sort(ascending), 0.5);
|
@@ -354,23 +440,39 @@ var merge = function(arrays) {
|
|
354
440
|
return merged;
|
355
441
|
};
|
356
442
|
|
357
|
-
var min = function(
|
358
|
-
var
|
359
|
-
|
360
|
-
|
361
|
-
|
362
|
-
|
363
|
-
if (
|
364
|
-
while (++i < n)
|
365
|
-
|
443
|
+
var min = function(values, valueof) {
|
444
|
+
var n = values.length,
|
445
|
+
i = -1,
|
446
|
+
value,
|
447
|
+
min;
|
448
|
+
|
449
|
+
if (valueof == null) {
|
450
|
+
while (++i < n) { // Find the first comparable value.
|
451
|
+
if ((value = values[i]) != null && value >= value) {
|
452
|
+
min = value;
|
453
|
+
while (++i < n) { // Compare the remaining values.
|
454
|
+
if ((value = values[i]) != null && min > value) {
|
455
|
+
min = value;
|
456
|
+
}
|
457
|
+
}
|
458
|
+
}
|
459
|
+
}
|
366
460
|
}
|
367
461
|
|
368
462
|
else {
|
369
|
-
while (++i < n)
|
370
|
-
|
463
|
+
while (++i < n) { // Find the first comparable value.
|
464
|
+
if ((value = valueof(values[i], i, values)) != null && value >= value) {
|
465
|
+
min = value;
|
466
|
+
while (++i < n) { // Compare the remaining values.
|
467
|
+
if ((value = valueof(values[i], i, values)) != null && min > value) {
|
468
|
+
min = value;
|
469
|
+
}
|
470
|
+
}
|
471
|
+
}
|
472
|
+
}
|
371
473
|
}
|
372
474
|
|
373
|
-
return
|
475
|
+
return min;
|
374
476
|
};
|
375
477
|
|
376
478
|
var permute = function(array, indexes) {
|
@@ -379,17 +481,21 @@ var permute = function(array, indexes) {
|
|
379
481
|
return permutes;
|
380
482
|
};
|
381
483
|
|
382
|
-
var scan = function(
|
383
|
-
if (!(n =
|
384
|
-
var
|
385
|
-
|
484
|
+
var scan = function(values, compare) {
|
485
|
+
if (!(n = values.length)) return;
|
486
|
+
var n,
|
487
|
+
i = 0,
|
386
488
|
j = 0,
|
387
489
|
xi,
|
388
|
-
xj =
|
490
|
+
xj = values[j];
|
389
491
|
|
390
|
-
if (
|
492
|
+
if (compare == null) compare = ascending;
|
391
493
|
|
392
|
-
while (++i < n)
|
494
|
+
while (++i < n) {
|
495
|
+
if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
|
496
|
+
xj = xi, j = i;
|
497
|
+
}
|
498
|
+
}
|
393
499
|
|
394
500
|
if (compare(xj, xj) === 0) return j;
|
395
501
|
};
|
@@ -409,21 +515,25 @@ var shuffle = function(array, i0, i1) {
|
|
409
515
|
return array;
|
410
516
|
};
|
411
517
|
|
412
|
-
var sum = function(
|
413
|
-
var
|
414
|
-
|
415
|
-
|
416
|
-
|
518
|
+
var sum = function(values, valueof) {
|
519
|
+
var n = values.length,
|
520
|
+
i = -1,
|
521
|
+
value,
|
522
|
+
sum = 0;
|
417
523
|
|
418
|
-
if (
|
419
|
-
while (++i < n)
|
524
|
+
if (valueof == null) {
|
525
|
+
while (++i < n) {
|
526
|
+
if (value = +values[i]) sum += value; // Note: zero and null are equivalent.
|
527
|
+
}
|
420
528
|
}
|
421
529
|
|
422
530
|
else {
|
423
|
-
while (++i < n)
|
531
|
+
while (++i < n) {
|
532
|
+
if (value = +valueof(values[i], i, values)) sum += value;
|
533
|
+
}
|
424
534
|
}
|
425
535
|
|
426
|
-
return
|
536
|
+
return sum;
|
427
537
|
};
|
428
538
|
|
429
539
|
var transpose = function(matrix) {
|
@@ -6405,7 +6515,8 @@ var formatLocale = function(locale) {
|
|
6405
6515
|
var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity$3,
|
6406
6516
|
currency = locale.currency,
|
6407
6517
|
decimal = locale.decimal,
|
6408
|
-
numerals = locale.numerals ? formatNumerals(locale.numerals) : identity$3
|
6518
|
+
numerals = locale.numerals ? formatNumerals(locale.numerals) : identity$3,
|
6519
|
+
percent = locale.percent || "%";
|
6409
6520
|
|
6410
6521
|
function newFormat(specifier) {
|
6411
6522
|
specifier = formatSpecifier(specifier);
|
@@ -6423,7 +6534,7 @@ var formatLocale = function(locale) {
|
|
6423
6534
|
// Compute the prefix and suffix.
|
6424
6535
|
// For SI-prefix, the suffix is lazily computed.
|
6425
6536
|
var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "",
|
6426
|
-
suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ?
|
6537
|
+
suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? percent : "";
|
6427
6538
|
|
6428
6539
|
// What format function should we use?
|
6429
6540
|
// Is this an integer type?
|
@@ -16203,6 +16314,7 @@ exports.scan = scan;
|
|
16203
16314
|
exports.shuffle = shuffle;
|
16204
16315
|
exports.sum = sum;
|
16205
16316
|
exports.ticks = ticks;
|
16317
|
+
exports.tickIncrement = tickIncrement;
|
16206
16318
|
exports.tickStep = tickStep;
|
16207
16319
|
exports.transpose = transpose;
|
16208
16320
|
exports.variance = variance;
|