stripchart 0.0.3

data/lib/stripchart/public/components/d3/src/scale/quantile.js

@@ -0,0 +1,54 @@
+import "../arrays/ascending";
+import "../arrays/bisect";
+import "../arrays/quantile";
+import "scale";
+
+d3.scale.quantile = function() {
+  return d3_scale_quantile([], []);
+};
+
+function d3_scale_quantile(domain, range) {
+  var thresholds;
+
+  function rescale() {
+    var k = 0,
+        q = range.length;
+    thresholds = [];
+    while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
+    return scale;
+  }
+
+  function scale(x) {
+    if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)];
+  }
+
+  scale.domain = function(x) {
+    if (!arguments.length) return domain;
+    domain = x.filter(function(d) { return !isNaN(d); }).sort(d3.ascending);
+    return rescale();
+  };
+
+  scale.range = function(x) {
+    if (!arguments.length) return range;
+    range = x;
+    return rescale();
+  };
+
+  scale.quantiles = function() {
+    return thresholds;
+  };
+
+  scale.invertExtent = function(y) {
+    y = range.indexOf(y);
+    return y < 0 ? [NaN, NaN] : [
+      y > 0 ? thresholds[y - 1] : domain[0],
+      y < thresholds.length ? thresholds[y] : domain[domain.length - 1]
+    ];
+  };
+
+  scale.copy = function() {
+    return d3_scale_quantile(domain, range); // copy on write!
+  };
+
+  return rescale();
+}

data/lib/stripchart/public/components/d3/src/scale/quantize.js

@@ -0,0 +1,44 @@
+import "scale";
+
+d3.scale.quantize = function() {
+  return d3_scale_quantize(0, 1, [0, 1]);
+};
+
+function d3_scale_quantize(x0, x1, range) {
+  var kx, i;
+
+  function scale(x) {
+    return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
+  }
+
+  function rescale() {
+    kx = range.length / (x1 - x0);
+    i = range.length - 1;
+    return scale;
+  }
+
+  scale.domain = function(x) {
+    if (!arguments.length) return [x0, x1];
+    x0 = +x[0];
+    x1 = +x[x.length - 1];
+    return rescale();
+  };
+
+  scale.range = function(x) {
+    if (!arguments.length) return range;
+    range = x;
+    return rescale();
+  };
+
+  scale.invertExtent = function(y) {
+    y = range.indexOf(y);
+    y = y < 0 ? NaN : y / kx + x0;
+    return [y, y + 1 / kx];
+  };
+
+  scale.copy = function() {
+    return d3_scale_quantize(x0, x1, range); // copy on write
+  };
+
+  return rescale();
+}

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

@@ -0,0 +1,10 @@
+d3.scale = {};
+
+function d3_scaleExtent(domain) {
+  var start = domain[0], stop = domain[domain.length - 1];
+  return start < stop ? [start, stop] : [stop, start];
+}
+
+function d3_scaleRange(scale) {
+  return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range());
+}

data/lib/stripchart/public/components/d3/src/scale/sqrt.js

@@ -0,0 +1,6 @@
+import "pow";
+import "scale";
+
+d3.scale.sqrt = function() {
+  return d3.scale.pow().exponent(.5);
+};

data/lib/stripchart/public/components/d3/src/scale/threshold.js

@@ -0,0 +1,36 @@
+import "../arrays/bisect";
+import "scale";
+
+d3.scale.threshold = function() {
+  return d3_scale_threshold([.5], [0, 1]);
+};
+
+function d3_scale_threshold(domain, range) {
+
+  function scale(x) {
+    if (x <= x) return range[d3.bisect(domain, x)];
+  }
+
+  scale.domain = function(_) {
+    if (!arguments.length) return domain;
+    domain = _;
+    return scale;
+  };
+
+  scale.range = function(_) {
+    if (!arguments.length) return range;
+    range = _;
+    return scale;
+  };
+
+  scale.invertExtent = function(y) {
+    y = range.indexOf(y);
+    return [domain[y - 1], domain[y]];
+  };
+
+  scale.copy = function() {
+    return d3_scale_threshold(domain, range);
+  };
+
+  return scale;
+};

data/lib/stripchart/public/components/d3/src/selection/append.js

@@ -0,0 +1,16 @@
+import "../core/document";
+import "../core/ns";
+import "selection";
+
+d3_selectionPrototype.append = function(name) {
+  name = d3_selection_creator(name);
+  return this.select(function() {
+    return this.appendChild(name.apply(this, arguments));
+  });
+};
+
+function d3_selection_creator(name) {
+  return typeof name === "function" ? name
+      : (name = d3.ns.qualify(name)).local ? function() { return d3_document.createElementNS(name.space, name.local); }
+      : function() { return d3_document.createElementNS(this.namespaceURI, name); };
+}

data/lib/stripchart/public/components/d3/src/selection/attr.js

@@ -0,0 +1,62 @@
+import "../core/ns";
+import "selection";
+
+d3_selectionPrototype.attr = function(name, value) {
+  if (arguments.length < 2) {
+
+    // For attr(string), return the attribute value for the first node.
+    if (typeof name === "string") {
+      var node = this.node();
+      name = d3.ns.qualify(name);
+      return name.local
+          ? node.getAttributeNS(name.space, name.local)
+          : node.getAttribute(name);
+    }
+
+    // For attr(object), the object specifies the names and values of the
+    // attributes to set or remove. The values may be functions that are
+    // evaluated for each element.
+    for (value in name) this.each(d3_selection_attr(value, name[value]));
+    return this;
+  }
+
+  return this.each(d3_selection_attr(name, value));
+};
+
+function d3_selection_attr(name, value) {
+  name = d3.ns.qualify(name);
+
+  // For attr(string, null), remove the attribute with the specified name.
+  function attrNull() {
+    this.removeAttribute(name);
+  }
+  function attrNullNS() {
+    this.removeAttributeNS(name.space, name.local);
+  }
+
+  // For attr(string, string), set the attribute with the specified name.
+  function attrConstant() {
+    this.setAttribute(name, value);
+  }
+  function attrConstantNS() {
+    this.setAttributeNS(name.space, name.local, value);
+  }
+
+  // For attr(string, function), evaluate the function for each element, and set
+  // or remove the attribute as appropriate.
+  function attrFunction() {
+    var x = value.apply(this, arguments);
+    if (x == null) this.removeAttribute(name);
+    else this.setAttribute(name, x);
+  }
+  function attrFunctionNS() {
+    var x = value.apply(this, arguments);
+    if (x == null) this.removeAttributeNS(name.space, name.local);
+    else this.setAttributeNS(name.space, name.local, x);
+  }
+
+  return value == null
+      ? (name.local ? attrNullNS : attrNull) : (typeof value === "function"
+      ? (name.local ? attrFunctionNS : attrFunction)
+      : (name.local ? attrConstantNS : attrConstant));
+}

data/lib/stripchart/public/components/d3/src/selection/call.js

@@ -0,0 +1,8 @@
+import "../core/array";
+import "selection";
+
+d3_selectionPrototype.call = function(callback) {
+  var args = d3_array(arguments);
+  callback.apply(args[0] = this, args);
+  return this;
+};

data/lib/stripchart/public/components/d3/src/selection/classed.js

@@ -0,0 +1,72 @@
+import "../format/collapse";
+import "../format/requote";
+import "selection";
+
+d3_selectionPrototype.classed = function(name, value) {
+  if (arguments.length < 2) {
+
+    // For classed(string), return true only if the first node has the specified
+    // class or classes. Note that even if the browser supports DOMTokenList, it
+    // probably doesn't support it on SVG elements (which can be animated).
+    if (typeof name === "string") {
+      var node = this.node(),
+          n = (name = name.trim().split(/^|\s+/g)).length,
+          i = -1;
+      if (value = node.classList) {
+        while (++i < n) if (!value.contains(name[i])) return false;
+      } else {
+        value = node.getAttribute("class");
+        while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
+      }
+      return true;
+    }
+
+    // For classed(object), the object specifies the names of classes to add or
+    // remove. The values may be functions that are evaluated for each element.
+    for (value in name) this.each(d3_selection_classed(value, name[value]));
+    return this;
+  }
+
+  // Otherwise, both a name and a value are specified, and are handled as below.
+  return this.each(d3_selection_classed(name, value));
+};
+
+function d3_selection_classedRe(name) {
+  return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
+}
+
+// Multiple class names are allowed (e.g., "foo bar").
+function d3_selection_classed(name, value) {
+  name = name.trim().split(/\s+/).map(d3_selection_classedName);
+  var n = name.length;
+
+  function classedConstant() {
+    var i = -1;
+    while (++i < n) name[i](this, value);
+  }
+
+  // When the value is a function, the function is still evaluated only once per
+  // element even if there are multiple class names.
+  function classedFunction() {
+    var i = -1, x = value.apply(this, arguments);
+    while (++i < n) name[i](this, x);
+  }
+
+  return typeof value === "function"
+      ? classedFunction
+      : classedConstant;
+}
+
+function d3_selection_classedName(name) {
+  var re = d3_selection_classedRe(name);
+  return function(node, value) {
+    if (c = node.classList) return value ? c.add(name) : c.remove(name);
+    var c = node.getAttribute("class") || "";
+    if (value) {
+      re.lastIndex = 0;
+      if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
+    } else {
+      node.setAttribute("class", d3_collapse(c.replace(re, " ")));
+    }
+  };
+}

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

@@ -0,0 +1,118 @@
+import "../arrays/map";
+import "selection";
+
+d3_selectionPrototype.data = function(value, key) {
+  var i = -1,
+      n = this.length,
+      group,
+      node;
+
+  // If no value is specified, return the first value.
+  if (!arguments.length) {
+    value = new Array(n = (group = this[0]).length);
+    while (++i < n) {
+      if (node = group[i]) {
+        value[i] = node.__data__;
+      }
+    }
+    return value;
+  }
+
+  function bind(group, groupData) {
+    var i,
+        n = group.length,
+        m = groupData.length,
+        n0 = Math.min(n, m),
+        updateNodes = new Array(m),
+        enterNodes = new Array(m),
+        exitNodes = new Array(n),
+        node,
+        nodeData;
+
+    if (key) {
+      var nodeByKeyValue = new d3_Map,
+          dataByKeyValue = new d3_Map,
+          keyValues = [],
+          keyValue;
+
+      for (i = -1; ++i < n;) {
+        keyValue = key.call(node = group[i], node.__data__, i);
+        if (nodeByKeyValue.has(keyValue)) {
+          exitNodes[i] = node; // duplicate selection key
+        } else {
+          nodeByKeyValue.set(keyValue, node);
+        }
+        keyValues.push(keyValue);
+      }
+
+      for (i = -1; ++i < m;) {
+        keyValue = key.call(groupData, nodeData = groupData[i], i);
+        if (node = nodeByKeyValue.get(keyValue)) {
+          updateNodes[i] = node;
+          node.__data__ = nodeData;
+        } else if (!dataByKeyValue.has(keyValue)) { // no duplicate data key
+          enterNodes[i] = d3_selection_dataNode(nodeData);
+        }
+        dataByKeyValue.set(keyValue, nodeData);
+        nodeByKeyValue.remove(keyValue);
+      }
+
+      for (i = -1; ++i < n;) {
+        if (nodeByKeyValue.has(keyValues[i])) {
+          exitNodes[i] = group[i];
+        }
+      }
+    } else {
+      for (i = -1; ++i < n0;) {
+        node = group[i];
+        nodeData = groupData[i];
+        if (node) {
+          node.__data__ = nodeData;
+          updateNodes[i] = node;
+        } else {
+          enterNodes[i] = d3_selection_dataNode(nodeData);
+        }
+      }
+      for (; i < m; ++i) {
+        enterNodes[i] = d3_selection_dataNode(groupData[i]);
+      }
+      for (; i < n; ++i) {
+        exitNodes[i] = group[i];
+      }
+    }
+
+    enterNodes.update
+        = updateNodes;
+
+    enterNodes.parentNode
+        = updateNodes.parentNode
+        = exitNodes.parentNode
+        = group.parentNode;
+
+    enter.push(enterNodes);
+    update.push(updateNodes);
+    exit.push(exitNodes);
+  }
+
+  var enter = d3_selection_enter([]),
+      update = d3_selection([]),
+      exit = d3_selection([]);
+
+  if (typeof value === "function") {
+    while (++i < n) {
+      bind(group = this[i], value.call(group, group.parentNode.__data__, i));
+    }
+  } else {
+    while (++i < n) {
+      bind(group = this[i], value);
+    }
+  }
+
+  update.enter = function() { return enter; };
+  update.exit = function() { return exit; };
+  return update;
+};
+
+function d3_selection_dataNode(data) {
+  return {__data__: data};
+}

data/lib/stripchart/public/components/d3/src/selection/datum.js

@@ -0,0 +1,7 @@
+import "selection";
+
+d3_selectionPrototype.datum = function(value) {
+  return arguments.length
+      ? this.property("__data__", value)
+      : this.property("__data__");
+};