@veritone-ce/design-system 2.9.0-next.2 → 2.9.0-next.3

package/dist/cjs/bundled_modules/d3-shape/src/curve/step.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function Step(context, t) {
+  this._context = context;
+  this._t = t;
+}
+
+Step.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x = this._y = NaN;
+    this._point = 0;
+  },
+  lineEnd: function() {
+    if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y);
+    if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
+    if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line;
+  },
+  point: function(x, y) {
+    x = +x, y = +y;
+    switch (this._point) {
+      case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;
+      case 1: this._point = 2; // falls through
+      default: {
+        if (this._t <= 0) {
+          this._context.lineTo(this._x, y);
+          this._context.lineTo(x, y);
+        } else {
+          var x1 = this._x * (1 - this._t) + x * this._t;
+          this._context.lineTo(x1, this._y);
+          this._context.lineTo(x1, y);
+        }
+        break;
+      }
+    }
+    this._x = x, this._y = y;
+  }
+};
+
+function curveStep(context) {
+  return new Step(context, 0.5);
+}
+
+function stepBefore(context) {
+  return new Step(context, 0);
+}
+
+function stepAfter(context) {
+  return new Step(context, 1);
+}
+
+exports.default = curveStep;
+exports.stepAfter = stepAfter;
+exports.stepBefore = stepBefore;

package/dist/cjs/bundled_modules/d3-shape/src/line.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var array = require('./array.js');
+var constant = require('./constant.js');
+var linear = require('./curve/linear.js');
+var path = require('./path.js');
+var point = require('./point.js');
+
+function line$2(x, y) {
+  var defined = constant.default(true),
+      context = null,
+      curve = linear.default,
+      output = null,
+      path$1 = path.withPath(line);
+
+  x = typeof x === "function" ? x : (x === undefined) ? point.x : constant.default(x);
+  y = typeof y === "function" ? y : (y === undefined) ? point.y : constant.default(y);
+
+  function line(data) {
+    var i,
+        n = (data = array.default(data)).length,
+        d,
+        defined0 = false,
+        buffer;
+
+    if (context == null) output = curve(buffer = path$1());
+
+    for (i = 0; i <= n; ++i) {
+      if (!(i < n && defined(d = data[i], i, data)) === defined0) {
+        if (defined0 = !defined0) output.lineStart();
+        else output.lineEnd();
+      }
+      if (defined0) output.point(+x(d, i, data), +y(d, i, data));
+    }
+
+    if (buffer) return output = null, buffer + "" || null;
+  }
+
+  line.x = function(_) {
+    return arguments.length ? (x = typeof _ === "function" ? _ : constant.default(+_), line) : x;
+  };
+
+  line.y = function(_) {
+    return arguments.length ? (y = typeof _ === "function" ? _ : constant.default(+_), line) : y;
+  };
+
+  line.defined = function(_) {
+    return arguments.length ? (defined = typeof _ === "function" ? _ : constant.default(!!_), line) : defined;
+  };
+
+  line.curve = function(_) {
+    return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve;
+  };
+
+  line.context = function(_) {
+    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context;
+  };
+
+  return line;
+}
+
+exports.default = line$2;

package/dist/cjs/bundled_modules/d3-shape/src/math.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const abs = Math.abs;
+const atan2 = Math.atan2;
+const cos = Math.cos;
+const max = Math.max;
+const min = Math.min;
+const sin = Math.sin;
+const sqrt = Math.sqrt;
+
+const epsilon = 1e-12;
+const pi = Math.PI;
+const halfPi = pi / 2;
+const tau = 2 * pi;
+
+function acos(x) {
+  return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
+}
+
+function asin(x) {
+  return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);
+}
+
+exports.abs = abs;
+exports.acos = acos;
+exports.asin = asin;
+exports.atan2 = atan2;
+exports.cos = cos;
+exports.epsilon = epsilon;
+exports.halfPi = halfPi;
+exports.max = max;
+exports.min = min;
+exports.pi = pi;
+exports.sin = sin;
+exports.sqrt = sqrt;
+exports.tau = tau;

package/dist/cjs/bundled_modules/d3-shape/src/noop.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function noop() {}
+
+exports.default = noop;

package/dist/cjs/bundled_modules/d3-shape/src/path.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var path = require('../../d3-path/src/path.js');
+
+function withPath(shape) {
+  let digits = 3;
+
+  shape.digits = function(_) {
+    if (!arguments.length) return digits;
+    if (_ == null) {
+      digits = null;
+    } else {
+      const d = Math.floor(_);
+      if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`);
+      digits = d;
+    }
+    return shape;
+  };
+
+  return () => new path.Path(digits);
+}
+
+exports.withPath = withPath;

package/dist/cjs/bundled_modules/d3-shape/src/point.js

@@ -0,0 +1,12 @@
+'use strict';
+
+function x(p) {
+  return p[0];
+}
+
+function y(p) {
+  return p[1];
+}
+
+exports.x = x;
+exports.y = y;

package/dist/cjs/bundled_modules/d3-shape/src/symbol/circle.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+
+var circle = {
+  draw(context, size) {
+    const r = math.sqrt(size / math.pi);
+    context.moveTo(r, 0);
+    context.arc(0, 0, r, 0, math.tau);
+  }
+};
+
+exports.default = circle;

package/dist/cjs/bundled_modules/d3-shape/src/symbol.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constant = require('./constant.js');
+var path = require('./path.js');
+var circle = require('./symbol/circle.js');
+
+function Symbol(type, size) {
+  let context = null,
+      path$1 = path.withPath(symbol);
+
+  type = typeof type === "function" ? type : constant.default(type || circle.default);
+  size = typeof size === "function" ? size : constant.default(size === undefined ? 64 : +size);
+
+  function symbol() {
+    let buffer;
+    if (!context) context = buffer = path$1();
+    type.apply(this, arguments).draw(context, +size.apply(this, arguments));
+    if (buffer) return context = null, buffer + "" || null;
+  }
+
+  symbol.type = function(_) {
+    return arguments.length ? (type = typeof _ === "function" ? _ : constant.default(_), symbol) : type;
+  };
+
+  symbol.size = function(_) {
+    return arguments.length ? (size = typeof _ === "function" ? _ : constant.default(+_), symbol) : size;
+  };
+
+  symbol.context = function(_) {
+    return arguments.length ? (context = _ == null ? null : _, symbol) : context;
+  };
+
+  return symbol;
+}
+
+exports.default = Symbol;

package/dist/cjs/bundled_modules/d3-time/src/day.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var interval = require('./interval.js');
+var duration = require('./duration.js');
+
+const timeDay = interval.timeInterval(
+  date => date.setHours(0, 0, 0, 0),
+  (date, step) => date.setDate(date.getDate() + step),
+  (start, end) => (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * duration.durationMinute) / duration.durationDay,
+  date => date.getDate() - 1
+);
+
+timeDay.range;
+
+const utcDay = interval.timeInterval((date) => {
+  date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setUTCDate(date.getUTCDate() + step);
+}, (start, end) => {
+  return (end - start) / duration.durationDay;
+}, (date) => {
+  return date.getUTCDate() - 1;
+});
+
+utcDay.range;
+
+const unixDay = interval.timeInterval((date) => {
+  date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setUTCDate(date.getUTCDate() + step);
+}, (start, end) => {
+  return (end - start) / duration.durationDay;
+}, (date) => {
+  return Math.floor(date / duration.durationDay);
+});
+
+unixDay.range;
+
+exports.timeDay = timeDay;
+exports.unixDay = unixDay;
+exports.utcDay = utcDay;

package/dist/cjs/bundled_modules/d3-time/src/duration.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const durationSecond = 1000;
+const durationMinute = durationSecond * 60;
+const durationHour = durationMinute * 60;
+const durationDay = durationHour * 24;
+const durationWeek = durationDay * 7;
+const durationMonth = durationDay * 30;
+const durationYear = durationDay * 365;
+
+exports.durationDay = durationDay;
+exports.durationHour = durationHour;
+exports.durationMinute = durationMinute;
+exports.durationMonth = durationMonth;
+exports.durationSecond = durationSecond;
+exports.durationWeek = durationWeek;
+exports.durationYear = durationYear;

package/dist/cjs/bundled_modules/d3-time/src/hour.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var interval = require('./interval.js');
+var duration = require('./duration.js');
+
+const timeHour = interval.timeInterval((date) => {
+  date.setTime(date - date.getMilliseconds() - date.getSeconds() * duration.durationSecond - date.getMinutes() * duration.durationMinute);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationHour);
+}, (start, end) => {
+  return (end - start) / duration.durationHour;
+}, (date) => {
+  return date.getHours();
+});
+
+timeHour.range;
+
+const utcHour = interval.timeInterval((date) => {
+  date.setUTCMinutes(0, 0, 0);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationHour);
+}, (start, end) => {
+  return (end - start) / duration.durationHour;
+}, (date) => {
+  return date.getUTCHours();
+});
+
+utcHour.range;
+
+exports.timeHour = timeHour;
+exports.utcHour = utcHour;

package/dist/cjs/bundled_modules/d3-time/src/interval.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const t0 = new Date, t1 = new Date;
+
+function timeInterval(floori, offseti, count, field) {
+
+  function interval(date) {
+    return floori(date = arguments.length === 0 ? new Date : new Date(+date)), date;
+  }
+
+  interval.floor = (date) => {
+    return floori(date = new Date(+date)), date;
+  };
+
+  interval.ceil = (date) => {
+    return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
+  };
+
+  interval.round = (date) => {
+    const d0 = interval(date), d1 = interval.ceil(date);
+    return date - d0 < d1 - date ? d0 : d1;
+  };
+
+  interval.offset = (date, step) => {
+    return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
+  };
+
+  interval.range = (start, stop, step) => {
+    const range = [];
+    start = interval.ceil(start);
+    step = step == null ? 1 : Math.floor(step);
+    if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
+    let previous;
+    do range.push(previous = new Date(+start)), offseti(start, step), floori(start);
+    while (previous < start && start < stop);
+    return range;
+  };
+
+  interval.filter = (test) => {
+    return timeInterval((date) => {
+      if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
+    }, (date, step) => {
+      if (date >= date) {
+        if (step < 0) while (++step <= 0) {
+          while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty
+        } else while (--step >= 0) {
+          while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty
+        }
+      }
+    });
+  };
+
+  if (count) {
+    interval.count = (start, end) => {
+      t0.setTime(+start), t1.setTime(+end);
+      floori(t0), floori(t1);
+      return Math.floor(count(t0, t1));
+    };
+
+    interval.every = (step) => {
+      step = Math.floor(step);
+      return !isFinite(step) || !(step > 0) ? null
+          : !(step > 1) ? interval
+          : interval.filter(field
+              ? (d) => field(d) % step === 0
+              : (d) => interval.count(0, d) % step === 0);
+    };
+  }
+
+  return interval;
+}
+
+exports.timeInterval = timeInterval;

package/dist/cjs/bundled_modules/d3-time/src/millisecond.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var interval = require('./interval.js');
+
+const millisecond = interval.timeInterval(() => {
+  // noop
+}, (date, step) => {
+  date.setTime(+date + step);
+}, (start, end) => {
+  return end - start;
+});
+
+// An optimized implementation for this simple case.
+millisecond.every = (k) => {
+  k = Math.floor(k);
+  if (!isFinite(k) || !(k > 0)) return null;
+  if (!(k > 1)) return millisecond;
+  return interval.timeInterval((date) => {
+    date.setTime(Math.floor(date / k) * k);
+  }, (date, step) => {
+    date.setTime(+date + step * k);
+  }, (start, end) => {
+    return (end - start) / k;
+  });
+};
+
+millisecond.range;
+
+exports.millisecond = millisecond;

package/dist/cjs/bundled_modules/d3-time/src/minute.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var interval = require('./interval.js');
+var duration = require('./duration.js');
+
+const timeMinute = interval.timeInterval((date) => {
+  date.setTime(date - date.getMilliseconds() - date.getSeconds() * duration.durationSecond);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationMinute);
+}, (start, end) => {
+  return (end - start) / duration.durationMinute;
+}, (date) => {
+  return date.getMinutes();
+});
+
+timeMinute.range;
+
+const utcMinute = interval.timeInterval((date) => {
+  date.setUTCSeconds(0, 0);
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationMinute);
+}, (start, end) => {
+  return (end - start) / duration.durationMinute;
+}, (date) => {
+  return date.getUTCMinutes();
+});
+
+utcMinute.range;
+
+exports.timeMinute = timeMinute;
+exports.utcMinute = utcMinute;

package/dist/cjs/bundled_modules/d3-time/src/month.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var interval = require('./interval.js');
+
+const timeMonth = interval.timeInterval((date) => {
+  date.setDate(1);
+  date.setHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setMonth(date.getMonth() + step);
+}, (start, end) => {
+  return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+}, (date) => {
+  return date.getMonth();
+});
+
+timeMonth.range;
+
+const utcMonth = interval.timeInterval((date) => {
+  date.setUTCDate(1);
+  date.setUTCHours(0, 0, 0, 0);
+}, (date, step) => {
+  date.setUTCMonth(date.getUTCMonth() + step);
+}, (start, end) => {
+  return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+}, (date) => {
+  return date.getUTCMonth();
+});
+
+utcMonth.range;
+
+exports.timeMonth = timeMonth;
+exports.utcMonth = utcMonth;

package/dist/cjs/bundled_modules/d3-time/src/second.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var interval = require('./interval.js');
+var duration = require('./duration.js');
+
+const second = interval.timeInterval((date) => {
+  date.setTime(date - date.getMilliseconds());
+}, (date, step) => {
+  date.setTime(+date + step * duration.durationSecond);
+}, (start, end) => {
+  return (end - start) / duration.durationSecond;
+}, (date) => {
+  return date.getUTCSeconds();
+});
+
+second.range;
+
+exports.second = second;

package/dist/cjs/bundled_modules/d3-time/src/ticks.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var duration = require('./duration.js');
+var millisecond = require('./millisecond.js');
+var second = require('./second.js');
+var minute = require('./minute.js');
+var hour = require('./hour.js');
+var day = require('./day.js');
+var week = require('./week.js');
+var month = require('./month.js');
+var year = require('./year.js');
+var bisector = require('../../d3-array/src/bisector.js');
+var ticks = require('../../d3-array/src/ticks.js');
+
+function ticker(year, month, week, day, hour, minute) {
+
+  const tickIntervals = [
+    [second.second,  1,      duration.durationSecond],
+    [second.second,  5,  5 * duration.durationSecond],
+    [second.second, 15, 15 * duration.durationSecond],
+    [second.second, 30, 30 * duration.durationSecond],
+    [minute,  1,      duration.durationMinute],
+    [minute,  5,  5 * duration.durationMinute],
+    [minute, 15, 15 * duration.durationMinute],
+    [minute, 30, 30 * duration.durationMinute],
+    [  hour,  1,      duration.durationHour  ],
+    [  hour,  3,  3 * duration.durationHour  ],
+    [  hour,  6,  6 * duration.durationHour  ],
+    [  hour, 12, 12 * duration.durationHour  ],
+    [   day,  1,      duration.durationDay   ],
+    [   day,  2,  2 * duration.durationDay   ],
+    [  week,  1,      duration.durationWeek  ],
+    [ month,  1,      duration.durationMonth ],
+    [ month,  3,  3 * duration.durationMonth ],
+    [  year,  1,      duration.durationYear  ]
+  ];
+
+  function ticks$1(start, stop, count) {
+    const reverse = stop < start;
+    if (reverse) [start, stop] = [stop, start];
+    const interval = count && typeof count.range === "function" ? count : tickInterval(start, stop, count);
+    const ticks = interval ? interval.range(start, +stop + 1) : []; // inclusive stop
+    return reverse ? ticks.reverse() : ticks;
+  }
+
+  function tickInterval(start, stop, count) {
+    const target = Math.abs(stop - start) / count;
+    const i = bisector.default(([,, step]) => step).right(tickIntervals, target);
+    if (i === tickIntervals.length) return year.every(ticks.tickStep(start / duration.durationYear, stop / duration.durationYear, count));
+    if (i === 0) return millisecond.millisecond.every(Math.max(ticks.tickStep(start, stop, count), 1));
+    const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
+    return t.every(step);
+  }
+
+  return [ticks$1, tickInterval];
+}
+
+const [utcTicks, utcTickInterval] = ticker(year.utcYear, month.utcMonth, week.utcSunday, day.unixDay, hour.utcHour, minute.utcMinute);
+const [timeTicks, timeTickInterval] = ticker(year.timeYear, month.timeMonth, week.timeSunday, day.timeDay, hour.timeHour, minute.timeMinute);
+
+exports.timeTickInterval = timeTickInterval;
+exports.timeTicks = timeTicks;
+exports.utcTickInterval = utcTickInterval;
+exports.utcTicks = utcTicks;

package/dist/cjs/bundled_modules/d3-time/src/week.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var interval = require('./interval.js');
+var duration = require('./duration.js');
+
+function timeWeekday(i) {
+  return interval.timeInterval((date) => {
+    date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
+    date.setHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setDate(date.getDate() + step * 7);
+  }, (start, end) => {
+    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * duration.durationMinute) / duration.durationWeek;
+  });
+}
+
+const timeSunday = timeWeekday(0);
+const timeMonday = timeWeekday(1);
+const timeTuesday = timeWeekday(2);
+const timeWednesday = timeWeekday(3);
+const timeThursday = timeWeekday(4);
+const timeFriday = timeWeekday(5);
+const timeSaturday = timeWeekday(6);
+
+timeSunday.range;
+timeMonday.range;
+timeTuesday.range;
+timeWednesday.range;
+timeThursday.range;
+timeFriday.range;
+timeSaturday.range;
+
+function utcWeekday(i) {
+  return interval.timeInterval((date) => {
+    date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
+    date.setUTCHours(0, 0, 0, 0);
+  }, (date, step) => {
+    date.setUTCDate(date.getUTCDate() + step * 7);
+  }, (start, end) => {
+    return (end - start) / duration.durationWeek;
+  });
+}
+
+const utcSunday = utcWeekday(0);
+const utcMonday = utcWeekday(1);
+const utcTuesday = utcWeekday(2);
+const utcWednesday = utcWeekday(3);
+const utcThursday = utcWeekday(4);
+const utcFriday = utcWeekday(5);
+const utcSaturday = utcWeekday(6);
+
+utcSunday.range;
+utcMonday.range;
+utcTuesday.range;
+utcWednesday.range;
+utcThursday.range;
+utcFriday.range;
+utcSaturday.range;
+
+exports.timeFriday = timeFriday;
+exports.timeMonday = timeMonday;
+exports.timeSaturday = timeSaturday;
+exports.timeSunday = timeSunday;
+exports.timeThursday = timeThursday;
+exports.timeTuesday = timeTuesday;
+exports.timeWednesday = timeWednesday;
+exports.utcFriday = utcFriday;
+exports.utcMonday = utcMonday;
+exports.utcSaturday = utcSaturday;
+exports.utcSunday = utcSunday;
+exports.utcThursday = utcThursday;
+exports.utcTuesday = utcTuesday;
+exports.utcWednesday = utcWednesday;