mdarray-sol 0.1.0-java

data/node_modules/dc/src/series-chart.js

@@ -0,0 +1,192 @@
+/**
+ * A series chart is a chart that shows multiple series of data overlaid on one chart, where the
+ * series is specified in the data. It is a specialization of Composite Chart and inherits all
+ * composite features other than recomposing the chart.
+ *
+ * Examples:
+ * - {@link http://dc-js.github.io/dc.js/examples/series.html Series Chart}
+ * @class seriesChart
+ * @memberof dc
+ * @mixes dc.compositeChart
+ * @example
+ * // create a series chart under #chart-container1 element using the default global chart group
+ * var seriesChart1 = dc.seriesChart("#chart-container1");
+ * // create a series chart under #chart-container2 element using chart group A
+ * var seriesChart2 = dc.seriesChart("#chart-container2", "chartGroupA");
+ * @param {String|node|d3.selection} parent - Any valid
+ * {@link https://github.com/mbostock/d3/wiki/Selections#selecting-elements d3 single selector} specifying
+ * a dom block element such as a div; or a dom element or d3 selection.
+ * @param {String} [chartGroup] - The name of the chart group this chart instance should be placed in.
+ * Interaction with a chart will only trigger events and redraws within the chart's group.
+ * @return {dc.seriesChart}
+ */
+dc.seriesChart = function (parent, chartGroup) {
+    var _chart = dc.compositeChart(parent, chartGroup);
+
+    function keySort (a, b) {
+        return d3.ascending(_chart.keyAccessor()(a), _chart.keyAccessor()(b));
+    }
+
+    var _charts = {};
+    var _chartFunction = dc.lineChart;
+    var _seriesAccessor;
+    var _seriesSort = d3.ascending;
+    var _valueSort = keySort;
+
+    _chart._mandatoryAttributes().push('seriesAccessor', 'chart');
+    _chart.shareColors(true);
+
+    _chart._preprocessData = function () {
+        var keep = [];
+        var childrenChanged;
+        var nester = d3.nest().key(_seriesAccessor);
+        if (_seriesSort) {
+            nester.sortKeys(_seriesSort);
+        }
+        if (_valueSort) {
+            nester.sortValues(_valueSort);
+        }
+        var nesting = nester.entries(_chart.data());
+        var children =
+            nesting.map(function (sub, i) {
+                var subChart = _charts[sub.key] || _chartFunction.call(_chart, _chart, chartGroup, sub.key, i);
+                if (!_charts[sub.key]) {
+                    childrenChanged = true;
+                }
+                _charts[sub.key] = subChart;
+                keep.push(sub.key);
+                return subChart
+                    .dimension(_chart.dimension())
+                    .group({all: d3.functor(sub.values)}, sub.key)
+                    .keyAccessor(_chart.keyAccessor())
+                    .valueAccessor(_chart.valueAccessor())
+                    .brushOn(_chart.brushOn());
+            });
+        // this works around the fact compositeChart doesn't really
+        // have a removal interface
+        Object.keys(_charts)
+            .filter(function (c) {return keep.indexOf(c) === -1;})
+            .forEach(function (c) {
+                clearChart(c);
+                childrenChanged = true;
+            });
+        _chart._compose(children);
+        if (childrenChanged && _chart.legend()) {
+            _chart.legend().render();
+        }
+    };
+
+    function clearChart (c) {
+        if (_charts[c].g()) {
+            _charts[c].g().remove();
+        }
+        delete _charts[c];
+    }
+
+    function resetChildren () {
+        Object.keys(_charts).map(clearChart);
+        _charts = {};
+    }
+
+    /**
+     * Get or set the chart function, which generates the child charts.
+     * @method chart
+     * @memberof dc.seriesChart
+     * @instance
+     * @example
+     * // put interpolation on the line charts used for the series
+     * chart.chart(function(c) { return dc.lineChart(c).interpolate('basis'); })
+     * // do a scatter series chart
+     * chart.chart(dc.scatterPlot)
+     * @param {Function} [chartFunction=dc.lineChart]
+     * @return {Function}
+     * @return {dc.seriesChart}
+     */
+    _chart.chart = function (chartFunction) {
+        if (!arguments.length) {
+            return _chartFunction;
+        }
+        _chartFunction = chartFunction;
+        resetChildren();
+        return _chart;
+    };
+
+    /**
+     * **mandatory**
+     *
+     * Get or set accessor function for the displayed series. Given a datum, this function
+     * should return the series that datum belongs to.
+     * @method seriesAccessor
+     * @memberof dc.seriesChart
+     * @instance
+     * @example
+     * // simple series accessor
+     * chart.seriesAccessor(function(d) { return "Expt: " + d.key[0]; })
+     * @param {Function} [accessor]
+     * @return {Function}
+     * @return {dc.seriesChart}
+     */
+    _chart.seriesAccessor = function (accessor) {
+        if (!arguments.length) {
+            return _seriesAccessor;
+        }
+        _seriesAccessor = accessor;
+        resetChildren();
+        return _chart;
+    };
+
+    /**
+     * Get or set a function to sort the list of series by, given series values.
+     * @method seriesSort
+     * @memberof dc.seriesChart
+     * @instance
+     * @see {@link https://github.com/mbostock/d3/wiki/Arrays#d3_ascending d3.ascending}
+     * @see {@link https://github.com/mbostock/d3/wiki/Arrays#d3_descending d3.descending}
+     * @example
+     * chart.seriesSort(d3.descending);
+     * @param {Function} [sortFunction=d3.ascending]
+     * @return {Function}
+     * @return {dc.seriesChart}
+     */
+    _chart.seriesSort = function (sortFunction) {
+        if (!arguments.length) {
+            return _seriesSort;
+        }
+        _seriesSort = sortFunction;
+        resetChildren();
+        return _chart;
+    };
+
+    /**
+     * Get or set a function to sort each series values by. By default this is the key accessor which,
+     * for example, will ensure a lineChart series connects its points in increasing key/x order,
+     * rather than haphazardly.
+     * @method valueSort
+     * @memberof dc.seriesChart
+     * @instance
+     * @see {@link https://github.com/mbostock/d3/wiki/Arrays#d3_ascending d3.ascending}
+     * @see {@link https://github.com/mbostock/d3/wiki/Arrays#d3_descending d3.descending}
+     * @example
+     * // Default value sort
+     * _chart.valueSort(function keySort (a, b) {
+     *     return d3.ascending(_chart.keyAccessor()(a), _chart.keyAccessor()(b));
+     * });
+     * @param {Function} [sortFunction]
+     * @return {Function}
+     * @return {dc.seriesChart}
+     */
+    _chart.valueSort = function (sortFunction) {
+        if (!arguments.length) {
+            return _valueSort;
+        }
+        _valueSort = sortFunction;
+        resetChildren();
+        return _chart;
+    };
+
+    // make compose private
+    _chart._compose = _chart.compose;
+    delete _chart.compose;
+
+    return _chart;
+};

data/node_modules/dc/src/stack-mixin.js

@@ -0,0 +1,319 @@
+/**
+ * Stack Mixin is an mixin that provides cross-chart support of stackability using d3.layout.stack.
+ * @name stackMixin
+ * @memberof dc
+ * @mixin
+ * @param {Object} _chart
+ * @return {dc.stackMixin}
+ */
+dc.stackMixin = function (_chart) {
+
+    function prepareValues (layer, layerIdx) {
+        var valAccessor = layer.accessor || _chart.valueAccessor();
+        layer.name = String(layer.name || layerIdx);
+        layer.values = layer.group.all().map(function (d, i) {
+            return {
+                x: _chart.keyAccessor()(d, i),
+                y: layer.hidden ? null : valAccessor(d, i),
+                data: d,
+                layer: layer.name,
+                hidden: layer.hidden
+            };
+        });
+
+        layer.values = layer.values.filter(domainFilter());
+        return layer.values;
+    }
+
+    var _stackLayout = d3.layout.stack()
+        .values(prepareValues);
+
+    var _stack = [];
+    var _titles = {};
+
+    var _hidableStacks = false;
+
+    function domainFilter () {
+        if (!_chart.x()) {
+            return d3.functor(true);
+        }
+        var xDomain = _chart.x().domain();
+        if (_chart.isOrdinal()) {
+            // TODO #416
+            //var domainSet = d3.set(xDomain);
+            return function () {
+                return true; //domainSet.has(p.x);
+            };
+        }
+        if (_chart.elasticX()) {
+            return function () { return true; };
+        }
+        return function (p) {
+            //return true;
+            return p.x >= xDomain[0] && p.x <= xDomain[xDomain.length - 1];
+        };
+    }
+
+    /**
+     * Stack a new crossfilter group onto this chart with an optional custom value accessor. All stacks
+     * in the same chart will share the same key accessor and therefore the same set of keys.
+     *
+     * For example, in a stacked bar chart, the bars of each stack will be positioned using the same set
+     * of keys on the x axis, while stacked vertically. If name is specified then it will be used to
+     * generate the legend label.
+     * @method stack
+     * @memberof dc.stackMixin
+     * @instance
+     * @see {@link https://github.com/square/crossfilter/wiki/API-Reference#group-map-reduce crossfilter.group}
+     * @example
+     * // stack group using default accessor
+     * chart.stack(valueSumGroup)
+     * // stack group using custom accessor
+     * .stack(avgByDayGroup, function(d){return d.value.avgByDay;});
+     * @param {crossfilter.group} group
+     * @param {String} [name]
+     * @param {Function} [accessor]
+     * @return {Array<{group: crossfilter.group, name: String, accessor: Function}>}
+     * @return {dc.stackMixin}
+     */
+    _chart.stack = function (group, name, accessor) {
+        if (!arguments.length) {
+            return _stack;
+        }
+
+        if (arguments.length <= 2) {
+            accessor = name;
+        }
+
+        var layer = {group: group};
+        if (typeof name === 'string') {
+            layer.name = name;
+        }
+        if (typeof accessor === 'function') {
+            layer.accessor = accessor;
+        }
+        _stack.push(layer);
+
+        return _chart;
+    };
+
+    dc.override(_chart, 'group', function (g, n, f) {
+        if (!arguments.length) {
+            return _chart._group();
+        }
+        _stack = [];
+        _titles = {};
+        _chart.stack(g, n);
+        if (f) {
+            _chart.valueAccessor(f);
+        }
+        return _chart._group(g, n);
+    });
+
+    /**
+     * Allow named stacks to be hidden or shown by clicking on legend items.
+     * This does not affect the behavior of hideStack or showStack.
+     * @method hidableStacks
+     * @memberof dc.stackMixin
+     * @instance
+     * @param {Boolean} [hidableStacks=false]
+     * @return {Boolean}
+     * @return {dc.stackMixin}
+     */
+    _chart.hidableStacks = function (hidableStacks) {
+        if (!arguments.length) {
+            return _hidableStacks;
+        }
+        _hidableStacks = hidableStacks;
+        return _chart;
+    };
+
+    function findLayerByName (n) {
+        var i = _stack.map(dc.pluck('name')).indexOf(n);
+        return _stack[i];
+    }
+
+    /**
+     * Hide all stacks on the chart with the given name.
+     * The chart must be re-rendered for this change to appear.
+     * @method hideStack
+     * @memberof dc.stackMixin
+     * @instance
+     * @param {String} stackName
+     * @return {dc.stackMixin}
+     */
+    _chart.hideStack = function (stackName) {
+        var layer = findLayerByName(stackName);
+        if (layer) {
+            layer.hidden = true;
+        }
+        return _chart;
+    };
+
+    /**
+     * Show all stacks on the chart with the given name.
+     * The chart must be re-rendered for this change to appear.
+     * @method showStack
+     * @memberof dc.stackMixin
+     * @instance
+     * @param {String} stackName
+     * @return {dc.stackMixin}
+     */
+    _chart.showStack = function (stackName) {
+        var layer = findLayerByName(stackName);
+        if (layer) {
+            layer.hidden = false;
+        }
+        return _chart;
+    };
+
+    _chart.getValueAccessorByIndex = function (index) {
+        return _stack[index].accessor || _chart.valueAccessor();
+    };
+
+    _chart.yAxisMin = function () {
+        var min = d3.min(flattenStack(), function (p) {
+            return (p.y + p.y0 < p.y0) ? (p.y + p.y0) : p.y0;
+        });
+
+        return dc.utils.subtract(min, _chart.yAxisPadding());
+
+    };
+
+    _chart.yAxisMax = function () {
+        var max = d3.max(flattenStack(), function (p) {
+            return p.y + p.y0;
+        });
+
+        return dc.utils.add(max, _chart.yAxisPadding());
+    };
+
+    function flattenStack () {
+        var valueses = _chart.data().map(function (layer) { return layer.values; });
+        return Array.prototype.concat.apply([], valueses);
+    }
+
+    _chart.xAxisMin = function () {
+        var min = d3.min(flattenStack(), dc.pluck('x'));
+        return dc.utils.subtract(min, _chart.xAxisPadding());
+    };
+
+    _chart.xAxisMax = function () {
+        var max = d3.max(flattenStack(), dc.pluck('x'));
+        return dc.utils.add(max, _chart.xAxisPadding());
+    };
+
+    /**
+     * Set or get the title function. Chart class will use this function to render svg title (usually interpreted by
+     * browser as tooltips) for each child element in the chart, i.e. a slice in a pie chart or a bubble in a bubble chart.
+     * Almost every chart supports title function however in grid coordinate chart you need to turn off brush in order to
+     * use title otherwise the brush layer will block tooltip trigger.
+     *
+     * If the first argument is a stack name, the title function will get or set the title for that stack. If stackName
+     * is not provided, the first stack is implied.
+     * @method title
+     * @memberof dc.stackMixin
+     * @instance
+     * @example
+     * // set a title function on 'first stack'
+     * chart.title('first stack', function(d) { return d.key + ': ' + d.value; });
+     * // get a title function from 'second stack'
+     * var secondTitleFunction = chart.title('second stack');
+     * @param {String} [stackName]
+     * @param {Function} [titleAccessor]
+     * @return {String}
+     * @return {dc.stackMixin}
+     */
+    dc.override(_chart, 'title', function (stackName, titleAccessor) {
+        if (!stackName) {
+            return _chart._title();
+        }
+
+        if (typeof stackName === 'function') {
+            return _chart._title(stackName);
+        }
+        if (stackName === _chart._groupName && typeof titleAccessor === 'function') {
+            return _chart._title(titleAccessor);
+        }
+
+        if (typeof titleAccessor !== 'function') {
+            return _titles[stackName] || _chart._title();
+        }
+
+        _titles[stackName] = titleAccessor;
+
+        return _chart;
+    });
+
+    /**
+     * Gets or sets the stack layout algorithm, which computes a baseline for each stack and
+     * propagates it to the next
+     * @method stackLayout
+     * @memberof dc.stackMixin
+     * @instance
+     * @see {@link http://github.com/mbostock/d3/wiki/Stack-Layout d3.layout.stack}
+     * @param {Function} [stack=d3.layout.stack]
+     * @return {Function}
+     * @return {dc.stackMixin}
+     */
+    _chart.stackLayout = function (stack) {
+        if (!arguments.length) {
+            return _stackLayout;
+        }
+        _stackLayout = stack;
+        if (_stackLayout.values() === d3.layout.stack().values()) {
+            _stackLayout.values(prepareValues);
+        }
+        return _chart;
+    };
+
+    function visability (l) {
+        return !l.hidden;
+    }
+
+    _chart.data(function () {
+        var layers = _stack.filter(visability);
+        return layers.length ? _chart.stackLayout()(layers) : [];
+    });
+
+    _chart._ordinalXDomain = function () {
+        var flat = flattenStack().map(dc.pluck('data'));
+        var ordered = _chart._computeOrderedGroups(flat);
+        return ordered.map(_chart.keyAccessor());
+    };
+
+    _chart.colorAccessor(function (d) {
+        var layer = this.layer || this.name || d.name || d.layer;
+        return layer;
+    });
+
+    _chart.legendables = function () {
+        return _stack.map(function (layer, i) {
+            return {
+                chart: _chart,
+                name: layer.name,
+                hidden: layer.hidden || false,
+                color: _chart.getColor.call(layer, layer.values, i)
+            };
+        });
+    };
+
+    _chart.isLegendableHidden = function (d) {
+        var layer = findLayerByName(d.name);
+        return layer ? layer.hidden : false;
+    };
+
+    _chart.legendToggle = function (d) {
+        if (_hidableStacks) {
+            if (_chart.isLegendableHidden(d)) {
+                _chart.showStack(d.name);
+            } else {
+                _chart.hideStack(d.name);
+            }
+            //_chart.redraw();
+            _chart.renderGroup();
+        }
+    };
+
+    return _chart;
+};