hyper-d3 1.0.0.lap23

data/lib/d3/random.rb

@@ -0,0 +1,14 @@
+module D3
+  class << self
+    # These return functions in d3,
+    # which doesn't feel very Ruby, so we call the functions
+    aliases_d3 %i[
+      randomUniform
+      randomNormal
+      randomLogNormal
+      randomBates
+      randomIrwinHall
+      randomExponential
+    ]
+  end
+end

data/lib/d3/search.rb

@@ -0,0 +1,30 @@
+# all these methods return indexes not values
+module D3
+  class Bisector
+    include D3::Native
+    alias_native_new :left
+    alias_native_new :right
+  end
+
+  class << self
+    aliases_d3 %i[
+      ascending
+      descending
+      bisect
+      bisectLeft
+      bisectRight
+    ]
+
+    def scan(array, &block)
+      if block_given?
+        @d3.JS.scan(array, block)
+      else
+        @d3.JS.scan(array)
+      end
+    end
+
+    def bisector(&block)
+      D3::Bisector.new @d3.JS.bisector(block)
+    end
+  end
+end

data/lib/d3/selection.rb

@@ -0,0 +1,151 @@
+module D3
+  class Selection
+    include D3::Native
+    aliases_native %i[size]
+    alias_native_new :empty?, :empty
+    alias_native_new :node
+    alias_native_new :nodes
+    alias_native_new :remove
+    alias_native_new :select
+    alias_native_new :select_all, :selectAll
+    alias_native_new :enter
+    alias_native_new :exit
+    alias_native_chainable :raise
+    alias_native_chainable :lower
+
+    def inspect
+      `#@native.toString()`
+    end
+
+    attributes_d3_block %i[text html]
+
+    def data(data=nil,key=nil,&block)
+      if block
+        self.class.new @native.JS.data(block)
+      elsif key != nil
+        self.class.new @native.JS.data(data,key)
+      elsif data != nil
+        self.class.new @native.JS.data(data)
+      else
+        @native.JS.data
+      end
+    end
+
+    def append(name=`undefined`, &block)
+      raise if `name !== undefined` and block_given?
+      name = block if block_given?
+      D3::Selection.new @native.JS.append(name.to_n)
+    end
+
+    def insert(name=`undefined`, before=`undefined`, &block)
+      if `name === undefined`
+        raise unless block_given?
+        D3::Selection.new @native.JS.insert(block.to_n)
+      elsif `before === undefined`
+        if block_given?
+          D3::Selection.new @native.JS.insert(name.to_n, block.to_n)
+        else
+          D3::Selection.new @native.JS.insert(name.to_n)
+        end
+      else
+        raise if block_given?
+        D3::Selection.new @native.JS.insert(name.to_n, before.to_n)
+      end
+    end
+
+    def call(context)
+      @native.JS.call(context.to_n)
+      self
+    end
+
+    def merge(other)
+      D3::Selection.new @native.JS.merge(other.to_n)
+    end
+
+    def classed(classes, yesno=`undefined`, &block)
+      if block_given?
+        @native.JS.classed(classes, block)
+        self
+      elsif `yesno !== undefined`
+        @native.JS.classed(classes, yesno)
+        self
+      else
+        @native.JS.classed(classes)
+      end
+    end
+
+    def filter(other=`undefined`,&block)
+      if block_given?
+        D3::Selection.new @native.JS.filter(block)
+      else
+        D3::Selection.new @native.JS.filter(other)
+      end
+    end
+
+    def each(other=`undefined`,&block)
+      if block_given?
+        @native.JS.each(block)
+      else
+        @native.JS.each(other)
+      end
+      self
+    end
+
+    def property(key, value=`undefined`)
+      if `value === undefined`
+        @native.JS.property(key)
+      else
+        @native.JS.property(key, value)
+        self
+      end
+    end
+
+    # Usage:
+    # style("foo")
+    # style("foo"){ value }
+    # style("foo", value)
+    # style("foo", value, priority)
+    def style(name, value=`undefined`, priority=`undefined`, &block)
+      if block
+        raise if `name === undefined` or `priority !== undefined` or `value !== undefined`
+        Selection.new @native.JS.style(name, block)
+      elsif `value === undefined`
+        @native.JS.style(name)
+      else
+        value = `value === nil ? null : value`
+        Selection.new @native.JS.style(name, value, priority)
+      end
+    end
+
+    # nil means something specific (reset value),
+    # so we need another special value
+    def attr(name, value=`undefined`, &block)
+      if block
+        @native.JS.attr(name, block)
+        self
+      elsif `value == undefined`
+        @native.JS.attr(name)
+      elsif value == nil
+        @native.JS.attr(name, `null`)
+        self
+      else
+        @native.JS.attr(name, value)
+        self
+      end
+    end
+  end
+
+  class << self
+    def selection
+      D3::Selection.new(@d3.JS.selection)
+    end
+
+    def select(selector)
+      D3::Selection.new(@d3.JS.select(selector))
+    end
+
+    def select_all(selector)
+      D3::Selection.new(@d3.JS.selectAll(selector))
+    end
+  end
+end

data/lib/d3/sequential_scale.rb

@@ -0,0 +1,31 @@
+module D3
+  class SequentialScale
+    include D3::Native
+
+    def call(t)
+      @native.call(t)
+    end
+
+    attributes_d3 %i[domain clamp]
+
+    def copy
+      self.class.new @native.JS.copy
+    end
+
+    def interpolator(&block)
+      if block_given?
+        @native.JS.interpolator(block)
+        self
+      else
+        @native.JS.interpolator
+      end
+    end
+  end
+
+  class << self
+    def scale_sequential(&block)
+      raise unless block_given?
+      SequentialScale.new @d3.JS.scaleSequential(block)
+    end
+  end
+end

data/lib/d3/set.rb

@@ -0,0 +1,30 @@
+module D3
+  class Set
+    include D3::Native
+    alias_native :empty?, :empty
+    alias_native :has?, :has
+    aliases_native %i[size values]
+    aliases_native_chainable %i[add clear remove]
+
+    def each(&block)
+      @native.JS.each(block)
+      self
+    end
+
+    def inspect
+      "#<D3::Set: {#{ values.join(", ") }}>"
+    end
+  end
+
+  class << self
+    def set(array=nil, &block)
+      if block_given?
+        D3::Set.new @d3.JS.set(array, proc{|x| yield(x)})
+      elsif array
+        D3::Set.new @d3.JS.set(array)
+      else
+        D3::Set.new @d3.JS.set()
+      end
+    end
+  end
+end

data/lib/d3/source/d3-drag.js

@@ -0,0 +1,234 @@
+// https://d3js.org/d3-drag/ Version 1.2.1. Copyright 2017 Mike Bostock.
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-dispatch'), require('d3-selection')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'd3-dispatch', 'd3-selection'], factory) :
+	(factory((global.d3 = global.d3 || {}),global.d3,global.d3));
+}(this, (function (exports,d3Dispatch,d3Selection) { 'use strict';
+
+function nopropagation() {
+  d3Selection.event.stopImmediatePropagation();
+}
+
+var noevent = function() {
+  d3Selection.event.preventDefault();
+  d3Selection.event.stopImmediatePropagation();
+};
+
+var nodrag = function(view) {
+  var root = view.document.documentElement,
+      selection = d3Selection.select(view).on("dragstart.drag", noevent, true);
+  if ("onselectstart" in root) {
+    selection.on("selectstart.drag", noevent, true);
+  } else {
+    root.__noselect = root.style.MozUserSelect;
+    root.style.MozUserSelect = "none";
+  }
+};
+
+function yesdrag(view, noclick) {
+  var root = view.document.documentElement,
+      selection = d3Selection.select(view).on("dragstart.drag", null);
+  if (noclick) {
+    selection.on("click.drag", noevent, true);
+    setTimeout(function() { selection.on("click.drag", null); }, 0);
+  }
+  if ("onselectstart" in root) {
+    selection.on("selectstart.drag", null);
+  } else {
+    root.style.MozUserSelect = root.__noselect;
+    delete root.__noselect;
+  }
+}
+
+var constant = function(x) {
+  return function() {
+    return x;
+  };
+};
+
+function DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch$$1) {
+  this.target = target;
+  this.type = type;
+  this.subject = subject;
+  this.identifier = id;
+  this.active = active;
+  this.x = x;
+  this.y = y;
+  this.dx = dx;
+  this.dy = dy;
+  this._ = dispatch$$1;
+}
+
+DragEvent.prototype.on = function() {
+  var value = this._.on.apply(this._, arguments);
+  return value === this._ ? this : value;
+};
+
+// Ignore right-click, since that should open the context menu.
+function defaultFilter() {
+  return !d3Selection.event.button;
+}
+
+function defaultContainer() {
+  return this.parentNode;
+}
+
+function defaultSubject(d) {
+  return d == null ? {x: d3Selection.event.x, y: d3Selection.event.y} : d;
+}
+
+function defaultTouchable() {
+  return "ontouchstart" in this;
+}
+
+var drag = function() {
+  var filter = defaultFilter,
+      container = defaultContainer,
+      subject = defaultSubject,
+      touchable = defaultTouchable,
+      gestures = {},
+      listeners = d3Dispatch.dispatch("start", "drag", "end"),
+      active = 0,
+      mousedownx,
+      mousedowny,
+      mousemoving,
+      touchending,
+      clickDistance2 = 0;
+
+  function drag(selection) {
+    selection
+        .on("mousedown.drag", mousedowned)
+      .filter(touchable)
+        .on("touchstart.drag", touchstarted)
+        .on("touchmove.drag", touchmoved)
+        .on("touchend.drag touchcancel.drag", touchended)
+        .style("touch-action", "none")
+        .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)");
+  }
+
+  function mousedowned() {
+    if (touchending || !filter.apply(this, arguments)) return;
+    var gesture = beforestart("mouse", container.apply(this, arguments), d3Selection.mouse, this, arguments);
+    if (!gesture) return;
+    d3Selection.select(d3Selection.event.view).on("mousemove.drag", mousemoved, true).on("mouseup.drag", mouseupped, true);
+    nodrag(d3Selection.event.view);
+    nopropagation();
+    mousemoving = false;
+    mousedownx = d3Selection.event.clientX;
+    mousedowny = d3Selection.event.clientY;
+    gesture("start");
+  }
+
+  function mousemoved() {
+    noevent();
+    if (!mousemoving) {
+      var dx = d3Selection.event.clientX - mousedownx, dy = d3Selection.event.clientY - mousedowny;
+      mousemoving = dx * dx + dy * dy > clickDistance2;
+    }
+    gestures.mouse("drag");
+  }
+
+  function mouseupped() {
+    d3Selection.select(d3Selection.event.view).on("mousemove.drag mouseup.drag", null);
+    yesdrag(d3Selection.event.view, mousemoving);
+    noevent();
+    gestures.mouse("end");
+  }
+
+  function touchstarted() {
+    if (!filter.apply(this, arguments)) return;
+    var touches = d3Selection.event.changedTouches,
+        c = container.apply(this, arguments),
+        n = touches.length, i, gesture;
+
+    for (i = 0; i < n; ++i) {
+      if (gesture = beforestart(touches[i].identifier, c, d3Selection.touch, this, arguments)) {
+        nopropagation();
+        gesture("start");
+      }
+    }
+  }
+
+  function touchmoved() {
+    var touches = d3Selection.event.changedTouches,
+        n = touches.length, i, gesture;
+
+    for (i = 0; i < n; ++i) {
+      if (gesture = gestures[touches[i].identifier]) {
+        noevent();
+        gesture("drag");
+      }
+    }
+  }
+
+  function touchended() {
+    var touches = d3Selection.event.changedTouches,
+        n = touches.length, i, gesture;
+
+    if (touchending) clearTimeout(touchending);
+    touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed!
+    for (i = 0; i < n; ++i) {
+      if (gesture = gestures[touches[i].identifier]) {
+        nopropagation();
+        gesture("end");
+      }
+    }
+  }
+
+  function beforestart(id, container, point, that, args) {
+    var p = point(container, id), s, dx, dy,
+        sublisteners = listeners.copy();
+
+    if (!d3Selection.customEvent(new DragEvent(drag, "beforestart", s, id, active, p[0], p[1], 0, 0, sublisteners), function() {
+      if ((d3Selection.event.subject = s = subject.apply(that, args)) == null) return false;
+      dx = s.x - p[0] || 0;
+      dy = s.y - p[1] || 0;
+      return true;
+    })) return;
+
+    return function gesture(type) {
+      var p0 = p, n;
+      switch (type) {
+        case "start": gestures[id] = gesture, n = active++; break;
+        case "end": delete gestures[id], --active; // nobreak
+        case "drag": p = point(container, id), n = active; break;
+      }
+      d3Selection.customEvent(new DragEvent(drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]);
+    };
+  }
+
+  drag.filter = function(_) {
+    return arguments.length ? (filter = typeof _ === "function" ? _ : constant(!!_), drag) : filter;
+  };
+
+  drag.container = function(_) {
+    return arguments.length ? (container = typeof _ === "function" ? _ : constant(_), drag) : container;
+  };
+
+  drag.subject = function(_) {
+    return arguments.length ? (subject = typeof _ === "function" ? _ : constant(_), drag) : subject;
+  };
+
+  drag.touchable = function(_) {
+    return arguments.length ? (touchable = typeof _ === "function" ? _ : constant(!!_), drag) : touchable;
+  };
+
+  drag.on = function() {
+    var value = listeners.on.apply(listeners, arguments);
+    return value === listeners ? drag : value;
+  };
+
+  drag.clickDistance = function(_) {
+    return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2);
+  };
+
+  return drag;
+};
+
+exports.drag = drag;
+exports.dragDisable = nodrag;
+exports.dragEnable = yesdrag;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));