Initial commit.

Author: jheer

.eslintrc

@@ -0,0 +1,13 @@
+parserOptions:
+    sourceType: "module"
+
+env:
+    es6: true
+    browser: true
+    node: true
+
+extends:
+    "eslint:recommended"
+
+rules:
+    no-cond-assign: 0

.gitignore

@@ -0,0 +1,5 @@
+*.sublime-workspace
+.DS_Store
+build/
+node_modules
+npm-debug.log

.npmignore

@@ -0,0 +1,3 @@
+*.sublime-*
+build/*.zip
+test/

LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2016, University of Washington Interactive Data Lab
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

index.js

@@ -0,0 +1,2 @@
+export {default as scale} from './src/scales';
+export {default as scheme} from './src/schemes';

package.json

@@ -0,0 +1,37 @@
+{
+  "name": "vega-scale",
+  "version": "1.0.0",
+  "description": "Scales and color schemes for visual encoding.",
+  "keywords": [
+    "vega",
+    "scales"
+  ],
+  "license": "BSD-3-Clause",
+  "author": {
+    "name": "Jeffrey Heer",
+    "url": "http://idl.cs.washington.edu"
+  },
+  "main": "build/vega-scale.js",
+  "jsnext:main": "index",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uwdata/vega-scale.git"
+  },
+  "scripts": {
+    "pretest": "rm -rf build && mkdir build && rollup -g d3-array:d3,d3-scale:d3,d3-scale-chromatic:d3 -f umd -n vega -o build/vega-scale.js -- index.js",
+    "test": "tape 'test/**/*-test.js' && eslint index.js src test",
+    "prepublish": "npm run test && uglifyjs build/vega-scale.js -c -m -o build/vega-scale.min.js",
+    "postpublish": "VERSION=`node -e 'console.log(require(\"./package.json\").version)'`; git push && git push --tags && zip -j build/vega-scale.zip -- LICENSE README.md build/vega-scale.js build/vega-scale.min.js"
+  },
+  "dependencies": {
+    "d3-array": "1",
+    "d3-scale": "1",
+    "d3-scale-chromatic": "1"
+  },
+  "devDependencies": {
+    "eslint": "2",
+    "rollup": "0.34",
+    "tape": "4",
+    "uglify-js": "2"
+  }
+}

src/band.js

@@ -0,0 +1,123 @@
+import {range as sequence, bisectRight} from 'd3-array';
+import {scaleOrdinal as ordinal} from 'd3-scale';
+
+export default function band() {
+  var scale = ordinal().unknown(undefined),
+      domain = scale.domain,
+      ordinalRange = scale.range,
+      range = [0, 1],
+      step,
+      bandwidth,
+      round = false,
+      paddingInner = 0,
+      paddingOuter = 0,
+      align = 0.5;
+
+  delete scale.unknown;
+
+  function rescale() {
+    var n = domain().length,
+        reverse = range[1] < range[0],
+        start = range[reverse - 0],
+        stop = range[1 - reverse];
+    step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);
+    if (round) step = Math.floor(step);
+    start += (stop - start - step * (n - paddingInner)) * align;
+    bandwidth = step * (1 - paddingInner);
+    if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);
+    var values = sequence(n).map(function(i) { return start + step * i; });
+    return ordinalRange(reverse ? values.reverse() : values);
+  }
+
+  scale.domain = function(_) {
+    return arguments.length ? (domain(_), rescale()) : domain();
+  };
+
+  scale.range = function(_) {
+    return arguments.length ? (range = [+_[0], +_[1]], rescale()) : range.slice();
+  };
+
+  scale.rangeRound = function(_) {
+    return range = [+_[0], +_[1]], round = true, rescale();
+  };
+
+  scale.bandwidth = function() {
+    return bandwidth;
+  };
+
+  scale.step = function() {
+    return step;
+  };
+
+  scale.round = function(_) {
+    return arguments.length ? (round = !!_, rescale()) : round;
+  };
+
+  scale.padding = function(_) {
+    return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;
+  };
+
+  scale.paddingInner = function(_) {
+    return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;
+  };
+
+  scale.paddingOuter = function(_) {
+    return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter;
+  };
+
+  scale.align = function(_) {
+    return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
+  };
+
+  scale.invertExtent = function(r0, r1) {
+    var lo = +r0,
+        hi = arguments.length > 1 ? +r1 : lo,
+        reverse = range[1] < range[0],
+        values = reverse ? ordinalRange().reverse() : ordinalRange(),
+        n = values.length - 1, a, b, t;
+
+    // order range inputs, bail if outside of scale range
+    if (hi < lo) t = lo, lo = hi, hi = t;
+    if (hi < values[0] || lo > range[1-reverse]) return undefined;
+
+    // binary search to index into scale range
+    a = Math.max(0, bisectRight(values, lo) - 1);
+    b = lo===hi ? a : bisectRight(values, hi) - 1;
+
+    // increment index a if lo is within padding gap
+    if (lo - values[a] > bandwidth + 1e-10) ++a;
+
+    if (reverse) t = a, a = n - b, b = n - t; // map + swap
+    return (a > b) ? undefined : domain().slice(a, b+1);
+  };
+
+  scale.copy = function() {
+    return band()
+        .domain(domain())
+        .range(range)
+        .round(round)
+        .paddingInner(paddingInner)
+        .paddingOuter(paddingOuter)
+        .align(align);
+  };
+
+  return rescale();
+}
+
+function pointish(scale) {
+  var copy = scale.copy;
+
+  scale.padding = scale.paddingOuter;
+  delete scale.paddingInner;
+  delete scale.paddingOuter;
+
+  scale.copy = function() {
+    return pointish(copy());
+  };
+
+  return scale;
+}
+
+export function point() {
+  return pointish(band().paddingInner(1));
+}

src/index.js

@@ -0,0 +1,66 @@
+import {scaleLinear, scaleSequential} from 'd3-scale';
+
+export default function index(scheme) {
+  var domain = [],
+      length = 0,
+      lookup = {},
+      interp = scheme ? scaleSequential(scheme) : scaleLinear();
+
+  function scale(_) {
+    if (lookup.hasOwnProperty(_)) return interp(lookup[_]);
+  }
+
+  scale.domain = function(_) {
+    if (!arguments.length) return domain.slice();
+    domain = _.slice();
+    length = domain.length;
+    lookup = {};
+    for (var i=0; i<length;) lookup[domain[i]] = i++;
+    interp.domain([0, length - 1]);
+    return scale;
+  };
+
+  if (!scheme) {
+    // sequential scales do not export an invert method
+
+    scale.invert = function(_) {
+      return domain[interp.invert(_)];
+    };
+
+    scale.invertExtent = function(r0, r1) {
+      if (arguments.length < 2) {
+        return (t = scale.invert(r0)) !== undefined ? [t] : [];
+      }
+
+      var lo = interp.invert(r0),
+          hi = interp.invert(r1),
+          t;
+
+      if (lo > hi) t = lo, lo = hi, hi = t;
+
+      return (hi < 0 || lo >= length) ? [] : domain.slice(
+        Math.max(0, Math.ceil(lo)),
+        Math.min(length, Math.floor(hi) + 1)
+      );
+    };
+  }
+
+  (scheme
+    ? ['interpolator']
+    : ['interpolate', 'range', 'rangeRound'])
+    .forEach(function(method) {
+      scale[method] = function() {
+        var r = interp[method].apply(null, arguments);
+        return arguments.length ? scale : r;
+      };
+    });
+
+  scale.copy = function() {
+    return (scheme
+      ? index(scheme).interpolator(interp.interpolator())
+      : index().interpolate(interp.interpolate()).range(interp.range())
+    ).domain(domain);
+  };
+
+  return scale;
+}

src/scales.js

@@ -0,0 +1,29 @@
+import * as $ from 'd3-scale';
+import {default as scaleBand, point as scalePoint} from './band';
+import scaleIndex from './index';
+
+var scales = {
+  // extended scale types
+  band:        scaleBand,
+  point:       scalePoint,
+  index:       scaleIndex,
+
+  // base scale types
+  identity:    $.scaleIdentity,
+  linear:      $.scaleLinear,
+  log:         $.scaleLog,
+  ordinal:     $.scaleOrdinal,
+  pow:         $.scalePow,
+  sqrt:        $.scaleSqrt,
+  quantile:    $.scaleQuantile,
+  quantize:    $.scaleQuantize,
+  threshold:   $.scaleThreshold,
+  time:        $.scaleTime,
+  utc:         $.scaleUtc,
+  sequential:  $.scaleSequential
+};
+
+export default function(name, scale) {
+  return arguments.length > 1 ? (scales[name] = scale, this)
+    : scales.hasOwnProperty(name) ? scales[name] : null;
+}

src/schemes.js

@@ -0,0 +1,68 @@
+import * as $ from 'd3-scale';
+import * as _ from 'd3-scale-chromatic';
+
+var schemes = {
+  // d3 built-in categorical palettes
+  category10:  $.schemeCategory10,
+  category20:  $.schemeCategory20,
+  category20b: $.schemeCategory20b,
+  category20c: $.schemeCategory20c,
+
+  // extended categorical palettes
+  accent:      _.schemeAccent,
+  dark2:       _.schemeDark2,
+  paired:      _.schemePaired,
+  pastel1:     _.schemePastel1,
+  pastel2:     _.schemePastel2,
+  set1:        _.schemeSet1,
+  set2:        _.schemeSet2,
+  set3:        _.schemeSet3,
+
+  // d3 built-in interpolators
+  cubehelix:   $.interpolateCubehelixDefault,
+  rainbow:     $.interpolateRainbow,
+  warm:        $.interpolateWarm,
+  cool:        $.interpolateCool,
+  viridis:     $.interpolateViridis,
+  magma:       $.interpolateMagma,
+  inferno:     $.interpolateInferno,
+  plasma:      $.interpolatePlasma,
+
+  // diverging
+  brbg:        _.interpolateBrBG,
+  prgn:        _.interpolatePRGn,
+  piyg:        _.interpolatePiYG,
+  puor:        _.interpolatePuOr,
+  rdbu:        _.interpolateRdBu,
+  rdgy:        _.interpolateRdGy,
+  rdylbu:      _.interpolateRdYlBu,
+  rdylgn:      _.interpolateRdYlGn,
+  spectral:    _.interpolateSpectral,
+
+  // sequential multi-hue
+  bugn:        _.interpolateBuGn,
+  bupu:        _.interpolateBuPu,
+  gnbu:        _.interpolateGnBu,
+  orrd:        _.interpolateOrRd,
+  pubugn:      _.interpolatePuBuGn,
+  pubu:        _.interpolatePuBu,
+  purd:        _.interpolatePuRd,
+  rdpu:        _.interpolateRdPu,
+  ylgnbu:      _.interpolateYlGnBu,
+  ylgn:        _.interpolateYlGn,
+  ylorbr:      _.interpolateYlOrBr,
+  ylorrd:      _.interpolateYlOrRd,
+
+  // sequential single-hue
+  blues:       _.interpolateBlues,
+  greens:      _.interpolateGreens,
+  greys:       _.interpolateGreys,
+  purples:     _.interpolatePurples,
+  reds:        _.interpolateReds,
+  oranges:     _.interpolateOranges
+};
+
+export default function scheme(name, scheme) {
+  return arguments.length > 1 ? (schemes[name] = scheme, this)
+    : schemes.hasOwnProperty(name) ? schemes[name] : null;
+}