stripmem 0.0.1

data/lib/stripmem/public/components/d3/src/time/week.js

@@ -0,0 +1,32 @@
+import "day";
+import "interval";
+import "time";
+import "year";
+
+d3_time_daySymbols.forEach(function(day, i) {
+  day = day.toLowerCase();
+  i = 7 - i;
+
+  var interval = d3.time[day] = d3_time_interval(function(date) {
+    (date = d3.time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7);
+    return date;
+  }, function(date, offset) {
+    date.setDate(date.getDate() + Math.floor(offset) * 7);
+  }, function(date) {
+    var day = d3.time.year(date).getDay();
+    return Math.floor((d3.time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i);
+  });
+
+  d3.time[day + "s"] = interval.range;
+  d3.time[day + "s"].utc = interval.utc.range;
+
+  d3.time[day + "OfYear"] = function(date) {
+    var day = d3.time.year(date).getDay();
+    return Math.floor((d3.time.dayOfYear(date) + (day + i) % 7) / 7);
+  };
+});
+
+d3.time.week = d3.time.sunday;
+d3.time.weeks = d3.time.sunday.range;
+d3.time.weeks.utc = d3.time.sunday.utc.range;
+d3.time.weekOfYear = d3.time.sundayOfYear;

data/lib/stripmem/public/components/d3/src/time/year.js

@@ -0,0 +1,16 @@
+import "day";
+import "interval";
+import "time";
+
+d3.time.year = d3_time_interval(function(date) {
+  date = d3.time.day(date);
+  date.setMonth(0, 1);
+  return date;
+}, function(date, offset) {
+  date.setFullYear(date.getFullYear() + offset);
+}, function(date) {
+  return date.getFullYear();
+});
+
+d3.time.years = d3.time.year.range;
+d3.time.years.utc = d3.time.year.utc.range;

data/lib/stripmem/public/components/d3/src/transition/attr.js

@@ -0,0 +1,58 @@
+import "../core/ns";
+import "../interpolate/interpolate";
+import "../interpolate/transform";
+import "transition";
+import "tween";
+
+d3_transitionPrototype.attr = function(nameNS, value) {
+  if (arguments.length < 2) {
+
+    // For attr(object), the object specifies the names and values of the
+    // attributes to transition. The values may be functions that are
+    // evaluated for each element.
+    for (value in nameNS) this.attr(value, nameNS[value]);
+    return this;
+  }
+
+  var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate,
+      name = d3.ns.qualify(nameNS);
+
+  // 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 attrTween(b) {
+    return b == null ? attrNull : (b += "", function() {
+      var a = this.getAttribute(name), i;
+      return a !== b && (i = interpolate(a, b), function(t) { this.setAttribute(name, i(t)); });
+    });
+  }
+  function attrTweenNS(b) {
+    return b == null ? attrNullNS : (b += "", function() {
+      var a = this.getAttributeNS(name.space, name.local), i;
+      return a !== b && (i = interpolate(a, b), function(t) { this.setAttributeNS(name.space, name.local, i(t)); });
+    });
+  }
+
+  return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween);
+};
+
+d3_transitionPrototype.attrTween = function(nameNS, tween) {
+  var name = d3.ns.qualify(nameNS);
+
+  function attrTween(d, i) {
+    var f = tween.call(this, d, i, this.getAttribute(name));
+    return f && function(t) { this.setAttribute(name, f(t)); };
+  }
+  function attrTweenNS(d, i) {
+    var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
+    return f && function(t) { this.setAttributeNS(name.space, name.local, f(t)); };
+  }
+
+  return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween);
+};

data/lib/stripmem/public/components/d3/src/transition/delay.js

@@ -0,0 +1,9 @@
+import "../selection/each";
+import "transition";
+
+d3_transitionPrototype.delay = function(value) {
+  var id = this.id;
+  return d3_selection_each(this, typeof value === "function"
+      ? function(node, i, j) { node.__transition__[id].delay = value.call(node, node.__data__, i, j) | 0; }
+      : (value |= 0, function(node) { node.__transition__[id].delay = value; }));
+};

data/lib/stripmem/public/components/d3/src/transition/duration.js

@@ -0,0 +1,9 @@
+import "../selection/each";
+import "transition";
+
+d3_transitionPrototype.duration = function(value) {
+  var id = this.id;
+  return d3_selection_each(this, typeof value === "function"
+      ? function(node, i, j) { node.__transition__[id].duration = Math.max(1, value.call(node, node.__data__, i, j) | 0); }
+      : (value = Math.max(1, value | 0), function(node) { node.__transition__[id].duration = value; }));
+};

data/lib/stripmem/public/components/d3/src/transition/each.js

@@ -0,0 +1,23 @@
+import "../selection/each";
+import "transition";
+
+d3_transitionPrototype.each = function(type, listener) {
+  var id = this.id;
+  if (arguments.length < 2) {
+    var inherit = d3_transitionInherit,
+        inheritId = d3_transitionInheritId;
+    d3_transitionInheritId = id;
+    d3_selection_each(this, function(node, i, j) {
+      d3_transitionInherit = node.__transition__[id];
+      type.call(node, node.__data__, i, j);
+    });
+    d3_transitionInherit = inherit;
+    d3_transitionInheritId = inheritId;
+  } else {
+    d3_selection_each(this, function(node) {
+      var transition = node.__transition__[id];
+      (transition.event || (transition.event = d3.dispatch("start", "end"))).on(type, listener);
+    });
+  }
+  return this;
+};

data/lib/stripmem/public/components/d3/src/transition/ease.js

@@ -0,0 +1,10 @@
+import "../interpolate/ease";
+import "../selection/each";
+import "transition";
+
+d3_transitionPrototype.ease = function(value) {
+  var id = this.id;
+  if (arguments.length < 1) return this.node().__transition__[id].ease;
+  if (typeof value !== "function") value = d3.ease.apply(d3, arguments);
+  return d3_selection_each(this, function(node) { node.__transition__[id].ease = value; });
+};

data/lib/stripmem/public/components/d3/src/transition/filter.js

@@ -0,0 +1,22 @@
+import "../selection/filter";
+import "transition";
+
+d3_transitionPrototype.filter = function(filter) {
+  var subgroups = [],
+      subgroup,
+      group,
+      node;
+
+  if (typeof filter !== "function") filter = d3_selection_filter(filter);
+
+  for (var j = 0, m = this.length; j < m; j++) {
+    subgroups.push(subgroup = []);
+    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+      if ((node = group[i]) && filter.call(node, node.__data__, i)) {
+        subgroup.push(node);
+      }
+    }
+  }
+
+  return d3_transition(subgroups, this.id, this.time).ease(this.ease());
+};

data/lib/stripmem/public/components/d3/src/transition/index.js

@@ -0,0 +1 @@
+import "transition";

data/lib/stripmem/public/components/d3/src/transition/remove.js

@@ -0,0 +1,8 @@
+import "transition";
+
+d3_transitionPrototype.remove = function() {
+  return this.each("end.transition", function() {
+    var p;
+    if (!this.__transition__ && (p = this.parentNode)) p.removeChild(this);
+  });
+};

data/lib/stripmem/public/components/d3/src/transition/select.js

@@ -0,0 +1,27 @@
+import "../selection/select";
+import "transition";
+
+d3_transitionPrototype.select = function(selector) {
+  var id = this.id,
+      subgroups = [],
+      subgroup,
+      subnode,
+      node;
+
+  selector = d3_selection_selector(selector);
+
+  for (var j = -1, m = this.length; ++j < m;) {
+    subgroups.push(subgroup = []);
+    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
+      if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i, j))) {
+        if ("__data__" in node) subnode.__data__ = node.__data__;
+        d3_transitionNode(subnode, i, id, node.__transition__[id]);
+        subgroup.push(subnode);
+      } else {
+        subgroup.push(null);
+      }
+    }
+  }
+
+  return d3_transition(subgroups, id);
+};

data/lib/stripmem/public/components/d3/src/transition/selectAll.js

@@ -0,0 +1,30 @@
+import "../selection/select";
+import "transition";
+
+d3_transitionPrototype.selectAll = function(selector) {
+  var id = this.id,
+      subgroups = [],
+      subgroup,
+      subnodes,
+      node,
+      subnode,
+      transition;
+
+  selector = d3_selection_selectorAll(selector);
+
+  for (var j = -1, m = this.length; ++j < m;) {
+    for (var group = this[j], i = -1, n = group.length; ++i < n;) {
+      if (node = group[i]) {
+        transition = node.__transition__[id];
+        subnodes = selector.call(node, node.__data__, i, j);
+        subgroups.push(subgroup = []);
+        for (var k = -1, o = subnodes.length; ++k < o;) {
+          if (subnode = subnodes[k]) d3_transitionNode(subnode, k, id, transition);
+          subgroup.push(subnode);
+        }
+      }
+    }
+  }
+
+  return d3_transition(subgroups, id);
+};

data/lib/stripmem/public/components/d3/src/transition/style.js

@@ -0,0 +1,53 @@
+import "../core/document";
+import "../interpolate/interpolate";
+import "transition";
+import "tween";
+
+d3_transitionPrototype.style = function(name, value, priority) {
+  var n = arguments.length;
+  if (n < 3) {
+
+    // For style(object) or style(object, string), 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. The optional string
+    // specifies the priority.
+    if (typeof name !== "string") {
+      if (n < 2) value = "";
+      for (priority in name) this.style(priority, name[priority], value);
+      return this;
+    }
+
+    // For style(string, string) or style(string, function), use the default
+    // priority. The priority is ignored for style(string, null).
+    priority = "";
+  }
+
+  // For style(name, null) or style(name, null, priority), remove the style
+  // property with the specified name. The priority is ignored.
+  function styleNull() {
+    this.style.removeProperty(name);
+  }
+
+  // For style(name, string) or style(name, string, priority), set the style
+  // property with the specified name, using the specified priority.
+  // Otherwise, a name, value and priority are specified, and handled as below.
+  function styleString(b) {
+    return b == null ? styleNull : (b += "", function() {
+      var a = d3_window.getComputedStyle(this, null).getPropertyValue(name), i;
+      return a !== b && (i = d3_interpolate(a, b), function(t) { this.style.setProperty(name, i(t), priority); });
+    });
+  }
+
+  return d3_transition_tween(this, "style." + name, value, styleString);
+};
+
+d3_transitionPrototype.styleTween = function(name, tween, priority) {
+  if (arguments.length < 3) priority = "";
+
+  function styleTween(d, i) {
+    var f = tween.call(this, d, i, d3_window.getComputedStyle(this, null).getPropertyValue(name));
+    return f && function(t) { this.style.setProperty(name, f(t), priority); };
+  }
+
+  return this.tween("style." + name, styleTween);
+};

data/lib/stripmem/public/components/d3/src/transition/subtransition.js

@@ -0,0 +1,25 @@
+import "transition";
+
+d3_transitionPrototype.transition = function() {
+  var id0 = this.id,
+      id1 = ++d3_transitionId,
+      subgroups = [],
+      subgroup,
+      group,
+      node,
+      transition;
+
+  for (var j = 0, m = this.length; j < m; j++) {
+    subgroups.push(subgroup = []);
+    for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+      if (node = group[i]) {
+        transition = Object.create(node.__transition__[id0]);
+        transition.delay += transition.duration;
+        d3_transitionNode(node, i, id1, transition);
+      }
+      subgroup.push(node);
+    }
+  }
+
+  return d3_transition(subgroups, id1);
+};

data/lib/stripmem/public/components/d3/src/transition/text.js

@@ -0,0 +1,11 @@
+import "transition";
+import "tween";
+
+d3_transitionPrototype.text = function(value) {
+  return d3_transition_tween(this, "text", value, d3_transition_text);
+};
+
+function d3_transition_text(b) {
+  if (b == null) b = "";
+  return function() { this.textContent = b; };
+}

data/lib/stripmem/public/components/d3/src/transition/transition.js

@@ -0,0 +1,118 @@
+import "../arrays/map";
+import "../core/subclass";
+import "../event/dispatch";
+import "../event/timer";
+import "../interpolate/ease";
+import "../selection/selection";
+
+function d3_transition(groups, id) {
+  d3_subclass(groups, d3_transitionPrototype);
+
+  groups.id = id; // Note: read-only!
+
+  return groups;
+}
+
+var d3_transitionPrototype = [],
+    d3_transitionId = 0,
+    d3_transitionInheritId,
+    d3_transitionInherit;
+
+d3_transitionPrototype.call = d3_selectionPrototype.call;
+d3_transitionPrototype.empty = d3_selectionPrototype.empty;
+d3_transitionPrototype.node = d3_selectionPrototype.node;
+d3_transitionPrototype.size = d3_selectionPrototype.size;
+
+d3.transition = function(selection) {
+  return arguments.length
+      ? (d3_transitionInheritId ? selection.transition() : selection)
+      : d3_selectionRoot.transition();
+};
+
+d3.transition.prototype = d3_transitionPrototype;
+
+import "select";
+import "selectAll";
+import "filter";
+import "attr";
+import "style";
+import "text";
+import "remove";
+import "ease";
+import "delay";
+import "duration";
+import "each";
+import "subtransition";
+import "tween";
+
+function d3_transitionNode(node, i, id, inherit) {
+  var lock = node.__transition__ || (node.__transition__ = {active: 0, count: 0}),
+      transition = lock[id];
+
+  if (!transition) {
+    var time = inherit.time;
+
+    transition = lock[id] = {
+      tween: new d3_Map,
+      time: time,
+      ease: inherit.ease,
+      delay: inherit.delay,
+      duration: inherit.duration
+    };
+
+    ++lock.count;
+
+    d3.timer(function(elapsed) {
+      var d = node.__data__,
+          ease = transition.ease,
+          delay = transition.delay,
+          duration = transition.duration,
+          tweened = [];
+
+      return delay <= elapsed
+          ? start(elapsed)
+          : d3.timer(start, delay, time), 1;
+
+      function start(elapsed) {
+        if (lock.active > id) return stop();
+        lock.active = id;
+        transition.event && transition.event.start.call(node, d, i);
+
+        transition.tween.forEach(function(key, value) {
+          if (value = value.call(node, d, i)) {
+            tweened.push(value);
+          }
+        });
+
+        if (!tick(elapsed)) d3.timer(tick, 0, time);
+        return 1;
+      }
+
+      function tick(elapsed) {
+        if (lock.active !== id) return stop();
+
+        var t = (elapsed - delay) / duration,
+            e = ease(t),
+            n = tweened.length;
+
+        while (n > 0) {
+          tweened[--n].call(node, e);
+        }
+
+        if (t >= 1) {
+          stop();
+          transition.event && transition.event.end.call(node, d, i);
+          return 1;
+        }
+      }
+
+      function stop() {
+        if (--lock.count) delete lock[id];
+        else delete node.__transition__;
+        return 1;
+      }
+    }, 0, time);
+
+    return transition;
+  }
+}

data/lib/stripmem/public/components/d3/src/transition/tween.js

@@ -0,0 +1,17 @@
+import "../selection/each";
+import "transition";
+
+d3_transitionPrototype.tween = function(name, tween) {
+  var id = this.id;
+  if (arguments.length < 2) return this.node().__transition__[id].tween.get(name);
+  return d3_selection_each(this, tween == null
+        ? function(node) { node.__transition__[id].tween.remove(name); }
+        : function(node) { node.__transition__[id].tween.set(name, tween); });
+};
+
+function d3_transition_tween(groups, name, value, tween) {
+  var id = groups.id;
+  return d3_selection_each(groups, typeof value === "function"
+      ? function(node, i, j) { node.__transition__[id].tween.set(name, tween(value.call(node, node.__data__, i, j))); }
+      : (value = tween(value), function(node) { node.__transition__[id].tween.set(name, value); }));
+}

data/lib/stripmem/public/components/d3/src/xhr/html.js

@@ -0,0 +1,12 @@
+import "../core/document";
+import "xhr";
+
+d3.html = function(url, callback) {
+  return d3_xhr(url, "text/html", d3_html, callback);
+};
+
+function d3_html(request) {
+  var range = d3_document.createRange();
+  range.selectNode(d3_document.body);
+  return range.createContextualFragment(request.responseText);
+}

data/lib/stripmem/public/components/d3/src/xhr/index.js

@@ -0,0 +1,5 @@
+import "xhr";
+import "text";
+import "json";
+import "html";
+import "xml";

data/lib/stripmem/public/components/d3/src/xhr/json.js

@@ -0,0 +1,9 @@
+import "xhr";
+
+d3.json = function(url, callback) {
+  return d3_xhr(url, "application/json", d3_json, callback);
+};
+
+function d3_json(request) {
+  return JSON.parse(request.responseText);
+}

data/lib/stripmem/public/components/d3/src/xhr/text.js

@@ -0,0 +1,5 @@
+import "xhr";
+
+d3.text = d3_xhrType(function(request) {
+  return request.responseText;
+});

data/lib/stripmem/public/components/d3/src/xhr/xhr.js

@@ -0,0 +1,118 @@
+import "../core/array";
+import "../core/document";
+import "../core/identity";
+import "../core/rebind";
+import "../event/dispatch";
+
+d3.xhr = d3_xhrType(d3_identity);
+
+function d3_xhrType(response) {
+  return function(url, mimeType, callback) {
+    if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, mimeType = null;
+    return d3_xhr(url, mimeType, response, callback);
+  };
+}
+
+function d3_xhr(url, mimeType, response, callback) {
+  var xhr = {},
+      dispatch = d3.dispatch("progress", "load", "error"),
+      headers = {},
+      request = new XMLHttpRequest,
+      responseType = null;
+
+  // If IE does not support CORS, use XDomainRequest.
+  if (d3_window.XDomainRequest
+      && !("withCredentials" in request)
+      && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest;
+
+  "onload" in request
+      ? request.onload = request.onerror = respond
+      : request.onreadystatechange = function() { request.readyState > 3 && respond(); };
+
+  function respond() {
+    var status = request.status, result;
+    if (!status && request.responseText || status >= 200 && status < 300 || status === 304) {
+      try {
+        result = response.call(xhr, request);
+      } catch (e) {
+        dispatch.error.call(xhr, e);
+        return;
+      }
+      dispatch.load.call(xhr, result);
+    } else {
+      dispatch.error.call(xhr, request);
+    }
+  }
+
+  request.onprogress = function(event) {
+    var o = d3.event;
+    d3.event = event;
+    try { dispatch.progress.call(xhr, request); }
+    finally { d3.event = o; }
+  };
+
+  xhr.header = function(name, value) {
+    name = (name + "").toLowerCase();
+    if (arguments.length < 2) return headers[name];
+    if (value == null) delete headers[name];
+    else headers[name] = value + "";
+    return xhr;
+  };
+
+  // If mimeType is non-null and no Accept header is set, a default is used.
+  xhr.mimeType = function(value) {
+    if (!arguments.length) return mimeType;
+    mimeType = value == null ? null : value + "";
+    return xhr;
+  };
+
+  // Specifies what type the response value should take;
+  // for instance, arraybuffer, blob, document, or text.
+  xhr.responseType = function(value) {
+    if (!arguments.length) return responseType;
+    responseType = value;
+    return xhr;
+  };
+
+  // Specify how to convert the response content to a specific type;
+  // changes the callback value on "load" events.
+  xhr.response = function(value) {
+    response = value;
+    return xhr;
+  };
+
+  // Convenience methods.
+  ["get", "post"].forEach(function(method) {
+    xhr[method] = function() {
+      return xhr.send.apply(xhr, [method].concat(d3_array(arguments)));
+    };
+  });
+
+  // If callback is non-null, it will be used for error and load events.
+  xhr.send = function(method, data, callback) {
+    if (arguments.length === 2 && typeof data === "function") callback = data, data = null;
+    request.open(method, url, true);
+    if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
+    if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);
+    if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
+    if (responseType != null) request.responseType = responseType;
+    if (callback != null) xhr.on("error", callback).on("load", function(request) { callback(null, request); });
+    request.send(data == null ? null : data);
+    return xhr;
+  };
+
+  xhr.abort = function() {
+    request.abort();
+    return xhr;
+  };
+
+  d3.rebind(xhr, dispatch, "on");
+
+  return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
+};
+
+function d3_xhr_fixCallback(callback) {
+  return callback.length === 1
+      ? function(error, request) { callback(error == null ? request : null); }
+      : callback;
+}

data/lib/stripmem/public/components/d3/src/xhr/xml.js

@@ -0,0 +1,5 @@
+import "xhr";
+
+d3.xml = d3_xhrType(function(request) {
+  return request.responseXML;
+});