stripchart 0.0.3

data/lib/stripchart/public/components/d3/src/arrays/shuffle.js

@@ -0,0 +1,8 @@
+d3.shuffle = function(array) {
+  var m = array.length, t, i;
+  while (m) {
+    i = Math.random() * m-- | 0;
+    t = array[m], array[m] = array[i], array[i] = t;
+  }
+  return array;
+};

data/lib/stripchart/public/components/d3/src/arrays/sum.js

@@ -0,0 +1,14 @@
+d3.sum = function(array, f) {
+  var s = 0,
+      n = array.length,
+      a,
+      i = -1;
+
+  if (arguments.length === 1) {
+    while (++i < n) if (!isNaN(a = +array[i])) s += a;
+  } else {
+    while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;
+  }
+
+  return s;
+};

data/lib/stripchart/public/components/d3/src/arrays/transpose.js

@@ -0,0 +1,5 @@
+import "zip";
+
+d3.transpose = function(matrix) {
+  return d3.zip.apply(d3, matrix);
+};

data/lib/stripchart/public/components/d3/src/arrays/values.js

@@ -0,0 +1,5 @@
+d3.values = function(map) {
+  var values = [];
+  for (var key in map) values.push(map[key]);
+  return values;
+};

data/lib/stripchart/public/components/d3/src/arrays/zip.js

@@ -0,0 +1,15 @@
+import "min";
+
+d3.zip = function() {
+  if (!(n = arguments.length)) return [];
+  for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) {
+    for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) {
+      zip[j] = arguments[j][i];
+    }
+  }
+  return zips;
+};
+
+function d3_zipLength(d) {
+  return d.length;
+}

data/lib/stripchart/public/components/d3/src/behavior/behavior.js

@@ -0,0 +1 @@
+d3.behavior = {};

data/lib/stripchart/public/components/d3/src/behavior/drag.js

@@ -0,0 +1,79 @@
+import "../core/document";
+import "../core/rebind";
+import "../event/drag";
+import "../event/event";
+import "../event/mouse";
+import "../event/touches";
+import "behavior";
+
+d3.behavior.drag = function() {
+  var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"),
+      origin = null,
+      mousedown = dragstart(d3_noop, d3.mouse, "mousemove", "mouseup"),
+      touchstart = dragstart(touchid, touchposition, "touchmove", "touchend");
+
+  function drag() {
+    this.on("mousedown.drag", mousedown)
+        .on("touchstart.drag", touchstart);
+  }
+
+  function touchid() {
+    return d3.event.changedTouches[0].identifier;
+  }
+
+  function touchposition(parent, id) {
+    return d3.touches(parent).filter(function(p) { return p.identifier === id; })[0];
+  }
+
+  function dragstart(id, position, move, end) {
+    return function() {
+      var target = this,
+          parent = target.parentNode,
+          event_ = event.of(target, arguments),
+          eventTarget = d3.event.target,
+          eventId = id(),
+          drag = eventId == null ? "drag" : "drag-" + eventId,
+          origin_ = position(parent, eventId),
+          dragged = 0,
+          offset,
+          w = d3.select(d3_window).on(move + "." + drag, moved).on(end + "." + drag, ended),
+          dragRestore = d3_event_dragSuppress();
+
+      if (origin) {
+        offset = origin.apply(target, arguments);
+        offset = [offset.x - origin_[0], offset.y - origin_[1]];
+      } else {
+        offset = [0, 0];
+      }
+
+      event_({type: "dragstart"});
+
+      function moved() {
+        if (!parent) return ended(); // target removed from DOM
+
+        var p = position(parent, eventId),
+            dx = p[0] - origin_[0],
+            dy = p[1] - origin_[1];
+
+        dragged |= dx | dy;
+        origin_ = p;
+
+        event_({type: "drag", x: p[0] + offset[0], y: p[1] + offset[1], dx: dx, dy: dy});
+      }
+
+      function ended() {
+        w.on(move + "." + drag, null).on(end + "." + drag, null);
+        dragRestore(dragged && d3.event.target === eventTarget);
+        event_({type: "dragend"});
+      }
+    };
+  }
+
+  drag.origin = function(x) {
+    if (!arguments.length) return origin;
+    origin = x;
+    return drag;
+  };
+
+  return d3.rebind(drag, event, "on");
+};

data/lib/stripchart/public/components/d3/src/behavior/index.js

@@ -0,0 +1,3 @@
+import "behavior";
+import "drag";
+import "zoom";

data/lib/stripchart/public/components/d3/src/behavior/zoom.js

@@ -0,0 +1,209 @@
+import "../core/document";
+import "../core/rebind";
+import "../event/drag";
+import "../event/event";
+import "../event/mouse";
+import "../event/touches";
+import "../selection/selection";
+import "behavior";
+
+d3.behavior.zoom = function() {
+  var translate = [0, 0],
+      translate0, // translate when we started zooming (to avoid drift)
+      scale = 1,
+      distance0, // distance² between initial touches
+      scale0, // scale when we started touching
+      scaleExtent = d3_behavior_zoomInfinity,
+      mousedown = "mousedown.zoom",
+      mousemove = "mousemove.zoom",
+      mouseup = "mouseup.zoom",
+      event = d3_eventDispatch(zoom, "zoom"),
+      x0,
+      x1,
+      y0,
+      y1,
+      touchtime; // time of last touchstart (to detect double-tap)
+
+  function zoom() {
+    this.on(mousedown, mousedowned)
+        .on(d3_behavior_zoomWheel + ".zoom", mousewheeled)
+        .on(mousemove, mousewheelreset)
+        .on("dblclick.zoom", dblclicked)
+        .on("touchstart.zoom", touchstarted);
+  }
+
+  zoom.translate = function(x) {
+    if (!arguments.length) return translate;
+    translate = x.map(Number);
+    rescale();
+    return zoom;
+  };
+
+  zoom.scale = function(x) {
+    if (!arguments.length) return scale;
+    scale = +x;
+    rescale();
+    return zoom;
+  };
+
+  zoom.scaleExtent = function(x) {
+    if (!arguments.length) return scaleExtent;
+    scaleExtent = x == null ? d3_behavior_zoomInfinity : x.map(Number);
+    return zoom;
+  };
+
+  zoom.x = function(z) {
+    if (!arguments.length) return x1;
+    x1 = z;
+    x0 = z.copy();
+    translate = [0, 0];
+    scale = 1;
+    return zoom;
+  };
+
+  zoom.y = function(z) {
+    if (!arguments.length) return y1;
+    y1 = z;
+    y0 = z.copy();
+    translate = [0, 0];
+    scale = 1;
+    return zoom;
+  };
+
+  function location(p) {
+    return [(p[0] - translate[0]) / scale, (p[1] - translate[1]) / scale];
+  }
+
+  function point(l) {
+    return [l[0] * scale + translate[0], l[1] * scale + translate[1]];
+  }
+
+  function scaleTo(s) {
+    scale = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
+  }
+
+  function translateTo(p, l) {
+    l = point(l);
+    translate[0] += p[0] - l[0];
+    translate[1] += p[1] - l[1];
+  }
+
+  function rescale() {
+    if (x1) x1.domain(x0.range().map(function(x) { return (x - translate[0]) / scale; }).map(x0.invert));
+    if (y1) y1.domain(y0.range().map(function(y) { return (y - translate[1]) / scale; }).map(y0.invert));
+  }
+
+  function dispatch(event) {
+    rescale();
+    event({type: "zoom", scale: scale, translate: translate});
+  }
+
+  function mousedowned() {
+    var target = this,
+        event_ = event.of(target, arguments),
+        eventTarget = d3.event.target,
+        dragged = 0,
+        w = d3.select(d3_window).on(mousemove, moved).on(mouseup, ended),
+        l = location(d3.mouse(target)),
+        dragRestore = d3_event_dragSuppress();
+
+    function moved() {
+      dragged = 1;
+      translateTo(d3.mouse(target), l);
+      dispatch(event_);
+    }
+
+    function ended() {
+      w.on(mousemove, d3_window === target ? mousewheelreset : null).on(mouseup, null);
+      dragRestore(dragged && d3.event.target === eventTarget);
+    }
+  }
+
+  function touchstarted() {
+    var target = this,
+        event_ = event.of(target, arguments),
+        touches = d3.touches(target),
+        now = Date.now(),
+        name = "zoom-" + d3.event.changedTouches[0].identifier,
+        touchmove = "touchmove." + name,
+        touchend = "touchend." + name,
+        w = d3.select(d3_window).on(touchmove, moved).on(touchend, ended).on(mousedown, null).on(mousemove, null), // prevent duplicate events
+        dragRestore = d3_event_dragSuppress();
+
+    scale0 = scale;
+    translate0 = {};
+    distance0 = 0;
+    touches.forEach(function(t) { translate0[t.identifier] = location(t); });
+
+    if (touches.length === 1) {
+      if (now - touchtime < 500) { // dbltap
+        var p = touches[0], l = location(touches[0]);
+        scaleTo(scale * 2);
+        translateTo(p, l);
+        d3_eventPreventDefault();
+        dispatch(event_);
+      }
+      touchtime = now;
+    } else if (touches.length > 1) {
+      var p = touches[0], q = touches[1],
+          dx = p[0] - q[0], dy = p[1] - q[1];
+      distance0 = dx * dx + dy * dy;
+    }
+
+    function moved() {
+      var touches = d3.touches(target),
+          p0 = touches[0],
+          l0 = translate0[p0.identifier];
+
+      if (p1 = touches[1]) {
+        var p1, l1 = translate0[p1.identifier],
+            scale1 = d3.event.scale;
+        if (scale1 == null) {
+          var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1;
+          scale1 = distance0 && Math.sqrt(distance1 / distance0);
+        }
+        p0 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
+        l0 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2];
+        scaleTo(scale1 * scale0);
+      }
+
+      touchtime = null;
+      translateTo(p0, l0);
+      dispatch(event_);
+    }
+
+    function ended() {
+      w.on(touchmove, null).on(touchend, null);
+      dragRestore();
+    }
+  }
+
+  function mousewheeled() {
+    d3_eventPreventDefault();
+    if (!translate0) translate0 = location(d3.mouse(this));
+    scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * scale);
+    translateTo(d3.mouse(this), translate0);
+    dispatch(event.of(this, arguments));
+  }
+
+  function mousewheelreset() {
+    translate0 = null;
+  }
+
+  function dblclicked() {
+    var p = d3.mouse(this), l = location(p), k = Math.log(scale) / Math.LN2;
+    scaleTo(Math.pow(2, d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1));
+    translateTo(p, l);
+    dispatch(event.of(this, arguments));
+  }
+
+  return d3.rebind(zoom, event, "on");
+};
+
+var d3_behavior_zoomInfinity = [0, Infinity]; // default scale extent
+
+// https://developer.mozilla.org/en-US/docs/Mozilla_event_reference/wheel
+var d3_behavior_zoomDelta, d3_behavior_zoomWheel
+    = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() { return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1); }, "wheel")
+    : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() { return d3.event.wheelDelta; }, "mousewheel")
+    : (d3_behavior_zoomDelta = function() { return -d3.event.detail; }, "MozMousePixelScroll");

data/lib/stripchart/public/components/d3/src/color/color.js

@@ -0,0 +1,5 @@
+function d3_Color() {}
+
+d3_Color.prototype.toString = function() {
+  return this.rgb() + "";
+};

data/lib/stripchart/public/components/d3/src/color/hcl.js

@@ -0,0 +1,42 @@
+import "../math/trigonometry";
+import "color";
+import "lab";
+import "rgb";
+
+d3.hcl = function(h, c, l) {
+  return arguments.length === 1
+      ? (h instanceof d3_Hcl ? d3_hcl(h.h, h.c, h.l)
+      : (h instanceof d3_Lab ? d3_lab_hcl(h.l, h.a, h.b)
+      : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b)))
+      : d3_hcl(+h, +c, +l);
+};
+
+function d3_hcl(h, c, l) {
+  return new d3_Hcl(h, c, l);
+}
+
+function d3_Hcl(h, c, l) {
+  this.h = h;
+  this.c = c;
+  this.l = l;
+}
+
+var d3_hclPrototype = d3_Hcl.prototype = new d3_Color;
+
+d3_hclPrototype.brighter = function(k) {
+  return d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));
+};
+
+d3_hclPrototype.darker = function(k) {
+  return d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));
+};
+
+d3_hclPrototype.rgb = function() {
+  return d3_hcl_lab(this.h, this.c, this.l).rgb();
+};
+
+function d3_hcl_lab(h, c, l) {
+  if (isNaN(h)) h = 0;
+  if (isNaN(c)) c = 0;
+  return d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);
+}

data/lib/stripchart/public/components/d3/src/color/hsl.js

@@ -0,0 +1,64 @@
+import "color";
+import "rgb";
+
+d3.hsl = function(h, s, l) {
+  return arguments.length === 1
+      ? (h instanceof d3_Hsl ? d3_hsl(h.h, h.s, h.l)
+      : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl))
+      : d3_hsl(+h, +s, +l);
+};
+
+function d3_hsl(h, s, l) {
+  return new d3_Hsl(h, s, l);
+}
+
+function d3_Hsl(h, s, l) {
+  this.h = h;
+  this.s = s;
+  this.l = l;
+}
+
+var d3_hslPrototype = d3_Hsl.prototype = new d3_Color;
+
+d3_hslPrototype.brighter = function(k) {
+  k = Math.pow(0.7, arguments.length ? k : 1);
+  return d3_hsl(this.h, this.s, this.l / k);
+};
+
+d3_hslPrototype.darker = function(k) {
+  k = Math.pow(0.7, arguments.length ? k : 1);
+  return d3_hsl(this.h, this.s, k * this.l);
+};
+
+d3_hslPrototype.rgb = function() {
+  return d3_hsl_rgb(this.h, this.s, this.l);
+};
+
+function d3_hsl_rgb(h, s, l) {
+  var m1,
+      m2;
+
+  /* Some simple corrections for h, s and l. */
+  h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h;
+  s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s;
+  l = l < 0 ? 0 : l > 1 ? 1 : l;
+
+  /* From FvD 13.37, CSS Color Module Level 3 */
+  m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
+  m1 = 2 * l - m2;
+
+  function v(h) {
+    if (h > 360) h -= 360;
+    else if (h < 0) h += 360;
+    if (h < 60) return m1 + (m2 - m1) * h / 60;
+    if (h < 180) return m2;
+    if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
+    return m1;
+  }
+
+  function vv(h) {
+    return Math.round(v(h) * 255);
+  }
+
+  return d3_rgb(vv(h + 120), vv(h), vv(h - 120));
+}