@canonical/yui 3.18.2-pre

package/build/series-cartesian/series-cartesian-debug.js

@@ -0,0 +1,947 @@
+YUI.add('series-cartesian', function (Y, NAME) {
+
+/**
+ * Provides functionality for creating a cartesian chart series.
+ *
+ * @module charts
+ * @submodule series-cartesian
+ */
+var Y_Lang = Y.Lang;
+
+/**
+ * An abstract class for creating series instances with horizontal and vertical axes.
+ * CartesianSeries provides the core functionality used by the following classes:
+ * <ul>
+ *      <li>{{#crossLink "LineSeries"}}{{/crossLink}}</li>
+ *      <li>{{#crossLink "MarkerSeries"}}{{/crossLink}}</li>
+ *      <li>{{#crossLink "AreaSeries"}}{{/crossLink}}</li>
+ *      <li>{{#crossLink "SplineSeries"}}{{/crossLink}}</li>
+ *      <li>{{#crossLink "AreaSplineSeries"}}{{/crossLink}}</li>
+ *      <li>{{#crossLink "ComboSeries"}}{{/crossLink}}</li>
+ *      <li>{{#crossLink "ComboSplineSeries"}}{{/crossLink}}</li>
+ *      <li>{{#crossLink "Histogram"}}{{/crossLink}}</li>
+ *  </ul>
+ *
+ * @class CartesianSeries
+ * @extends SeriesBase
+ * @constructor
+ * @param {Object} config (optional) Configuration parameters.
+ * @submodule series-base
+ */
+Y.CartesianSeries = Y.Base.create("cartesianSeries", Y.SeriesBase, [], {
+    /**
+     * Storage for `xDisplayName` attribute.
+     *
+     * @property _xDisplayName
+     * @type String
+     * @private
+     */
+    _xDisplayName: null,
+
+    /**
+     * Storage for `yDisplayName` attribute.
+     *
+     * @property _yDisplayName
+     * @type String
+     * @private
+     */
+    _yDisplayName: null,
+
+    /**
+     * Th x-coordinate for the left edge of the series.
+     *
+     * @property _leftOrigin
+     * @type String
+     * @private
+     */
+    _leftOrigin: null,
+
+    /**
+     * The y-coordinate for the bottom edge of the series.
+     *
+     * @property _bottomOrigin
+     * @type String
+     * @private
+     */
+    _bottomOrigin: null,
+
+    /**
+     * Adds event listeners.
+     *
+     * @method addListeners
+     * @private
+     */
+    addListeners: function()
+    {
+        var xAxis = this.get("xAxis"),
+            yAxis = this.get("yAxis");
+        if(xAxis)
+        {
+            this._xDataReadyHandle = xAxis.after("dataReady", Y.bind(this._xDataChangeHandler, this));
+            this._xDataUpdateHandle = xAxis.after("dataUpdate", Y.bind(this._xDataChangeHandler, this));
+        }
+        if(yAxis)
+        {
+            this._yDataReadyHandle = yAxis.after("dataReady", Y.bind(this._yDataChangeHandler, this));
+            this._yDataUpdateHandle = yAxis.after("dataUpdate", Y.bind(this._yDataChangeHandler, this));
+        }
+        this._xAxisChangeHandle = this.after("xAxisChange", this._xAxisChangeHandler);
+        this._yAxisChangeHandle = this.after("yAxisChange", this._yAxisChangeHandler);
+        this._stylesChangeHandle = this.after("stylesChange", function() {
+            var axesReady = this._updateAxisBase();
+            if(axesReady)
+            {
+                this.draw();
+            }
+        });
+        this._widthChangeHandle = this.after("widthChange", function() {
+            var axesReady = this._updateAxisBase();
+            if(axesReady)
+            {
+                this.draw();
+            }
+        });
+        this._heightChangeHandle = this.after("heightChange", function() {
+            var axesReady = this._updateAxisBase();
+            if(axesReady)
+            {
+                this.draw();
+            }
+        });
+        this._visibleChangeHandle = this.after("visibleChange", this._handleVisibleChange);
+    },
+
+    /**
+     * Event handler for the xAxisChange event.
+     *
+     * @method _xAxisChangeHandler
+     * @param {Object} e Event object.
+     * @private
+     */
+    _xAxisChangeHandler: function()
+    {
+        var xAxis = this.get("xAxis");
+        xAxis.after("dataReady", Y.bind(this._xDataChangeHandler, this));
+        xAxis.after("dataUpdate", Y.bind(this._xDataChangeHandler, this));
+    },
+
+    /**
+     * Event handler the yAxisChange event.
+     *
+     * @method _yAxisChangeHandler
+     * @param {Object} e Event object.
+     * @private
+     */
+    _yAxisChangeHandler: function()
+    {
+        var yAxis = this.get("yAxis");
+        yAxis.after("dataReady", Y.bind(this._yDataChangeHandler, this));
+        yAxis.after("dataUpdate", Y.bind(this._yDataChangeHandler, this));
+    },
+
+    /**
+     * Constant used to generate unique id.
+     *
+     * @property GUID
+     * @type String
+     * @private
+     */
+    GUID: "yuicartesianseries",
+
+    /**
+     * Event handler for xDataChange event.
+     *
+     * @method _xDataChangeHandler
+     * @param {Object} event Event object.
+     * @private
+     */
+    _xDataChangeHandler: function()
+    {
+        var axesReady = this._updateAxisBase();
+        if(axesReady)
+        {
+            this.draw();
+        }
+    },
+
+    /**
+     * Event handler for yDataChange event.
+     *
+     * @method _yDataChangeHandler
+     * @param {Object} event Event object.
+     * @private
+     */
+    _yDataChangeHandler: function()
+    {
+        var axesReady = this._updateAxisBase();
+        if(axesReady)
+        {
+            this.draw();
+        }
+    },
+
+    /**
+     * Checks to ensure that both xAxis and yAxis data are available. If so, set the `xData` and `yData` attributes
+     * and return `true`. Otherwise, return `false`.
+     *
+     * @method _updateAxisBase
+     * @return Boolean
+     * @private
+     */
+    _updateAxisBase: function()
+    {
+        var xAxis = this.get("xAxis"),
+            yAxis = this.get("yAxis"),
+            xKey = this.get("xKey"),
+            yKey = this.get("yKey"),
+            yData,
+            xData,
+            xReady,
+            yReady,
+            ready;
+        if(!xAxis || !yAxis || !xKey || !yKey)
+        {
+            ready = false;
+        }
+        else
+        {
+            xData = xAxis.getDataByKey(xKey);
+            yData = yAxis.getDataByKey(yKey);
+            if(Y_Lang.isArray(xKey))
+            {
+                xReady = (xData && Y.Object.size(xData) > 0) ? this._checkForDataByKey(xData, xKey) : false;
+            }
+            else
+            {
+                xReady = xData ? true : false;
+            }
+            if(Y_Lang.isArray(yKey))
+            {
+                yReady = (yData && Y.Object.size(yData) > 0) ? this._checkForDataByKey(yData, yKey) : false;
+            }
+            else
+            {
+                yReady = yData ? true : false;
+            }
+            ready = xReady && yReady;
+            if(ready)
+            {
+                this.set("xData", xData);
+                this.set("yData", yData);
+            }
+        }
+        return ready;
+    },
+
+    /**
+     * Checks to see if all keys of a data object exist and contain data.
+     *
+     * @method _checkForDataByKey
+     * @param {Object} obj The object to check
+     * @param {Array} keys The keys to check
+     * @return Boolean
+     * @private
+     */
+    _checkForDataByKey: function(obj, keys)
+    {
+        var i,
+            len = keys.length,
+            hasData = false;
+        for(i = 0; i < len; i = i + 1)
+        {
+            if(obj[keys[i]])
+            {
+                hasData = true;
+                break;
+            }
+        }
+        return hasData;
+    },
+
+    /**
+     * Draws the series is the xAxis and yAxis data are both available.
+     *
+     * @method validate
+     * @private
+     */
+    validate: function()
+    {
+        if((this.get("xData") && this.get("yData")) || this._updateAxisBase())
+        {
+            this.draw();
+        }
+        else
+        {
+            this.fire("drawingComplete");
+        }
+    },
+
+    /**
+     * Calculates the coordinates for the series.
+     *
+     * @method setAreaData
+     * @protected
+     */
+    setAreaData: function()
+    {
+        var w = this.get("width"),
+            h = this.get("height"),
+            xAxis = this.get("xAxis"),
+            yAxis = this.get("yAxis"),
+            xData = this._copyData(this.get("xData")),
+            yData = this._copyData(this.get("yData")),
+            direction = this.get("direction"),
+            dataLength = direction === "vertical" ? yData.length : xData.length,
+            xOffset = xAxis.getEdgeOffset(xAxis.getTotalMajorUnits(), w),
+            yOffset = yAxis.getEdgeOffset(yAxis.getTotalMajorUnits(), h),
+            padding = this.get("styles").padding,
+			leftPadding = padding.left,
+			topPadding = padding.top,
+			dataWidth = w - (leftPadding + padding.right + xOffset * 2),
+			dataHeight = h - (topPadding + padding.bottom + yOffset * 2),
+			xMax = xAxis.get("maximum"),
+			xMin = xAxis.get("minimum"),
+			yMax = yAxis.get("maximum"),
+			yMin = yAxis.get("minimum"),
+            graphic = this.get("graphic"),
+            yAxisType = yAxis.get("type"),
+            reverseYCoords = (yAxisType === "numeric" || yAxisType === "stacked"),
+            xcoords,
+            ycoords,
+            xOriginValue = xAxis.getOrigin(),
+            yOriginValue = yAxis.getOrigin();
+        graphic.set("width", w);
+        graphic.set("height", h);
+        xOffset = xOffset + leftPadding;
+        yOffset = reverseYCoords ? yOffset + dataHeight + topPadding + padding.bottom : topPadding + yOffset;
+        this._leftOrigin = Math.round(xAxis._getCoordFromValue(xMin, xMax, dataWidth, xOriginValue, xOffset, false));
+        this._bottomOrigin = Math.round(yAxis._getCoordFromValue(yMin, yMax, dataHeight, yOriginValue, yOffset, reverseYCoords));
+
+        xcoords = this._getCoords(xMin, xMax, dataWidth, xData, xAxis, xOffset, false);
+        ycoords = this._getCoords(yMin, yMax, dataHeight, yData, yAxis, yOffset, reverseYCoords);
+        this.set("xcoords", xcoords);
+		this.set("ycoords", ycoords);
+        this._dataLength = dataLength;
+        this._setXMarkerPlane(xcoords, dataLength);
+        this._setYMarkerPlane(ycoords, dataLength);
+    },
+
+    /**
+     * Returns either an array coordinates or an object key valued arrays of coordinates depending on the input.
+     * If the input data is an array, an array is returned. If the input data is an object, an object will be returned.
+     *
+     * @method _getCoords
+     * @param {Number} min The minimum value of the range of data.
+     * @param {Number} max The maximum value of the range of data.
+     * @param {Number} length The length, in pixels, of across which the coordinates will be calculated.
+     * @param {AxisBase} axis The axis in which the data is bound.
+     * @param {Number} offset The value in which to offet the first coordinate.
+     * @param {Boolean} reverse Indicates whether to calculate the coordinates in reverse order.
+     * @return Array|Object
+     * @private
+     */
+    _getCoords: function(min, max, length, data, axis, offset, reverse)
+    {
+        var coords,
+            key;
+        if(Y_Lang.isArray(data))
+        {
+            coords = axis._getCoordsFromValues(min, max, length, data, offset, reverse);
+        }
+        else
+        {
+            coords = {};
+            for(key in data)
+            {
+                if(data.hasOwnProperty(key))
+                {
+                    coords[key] = this._getCoords.apply(this, [min, max, length, data[key], axis, offset, reverse]);
+                }
+            }
+        }
+        return coords;
+    },
+
+    /**
+     * Used to cache xData and yData in the setAreaData method. Returns a copy of an
+     * array if an array is received as the param and returns an object literal of
+     * array copies if an object literal is received as the param.
+     *
+     * @method _copyData
+     * @param {Array|Object} val The object or array to be copied.
+     * @return Array|Object
+     * @private
+     */
+    _copyData: function(val)
+    {
+        var copy,
+            key;
+        if(Y_Lang.isArray(val))
+        {
+            copy = val.concat();
+        }
+        else
+        {
+            copy = {};
+            for(key in val)
+            {
+                if(val.hasOwnProperty(key))
+                {
+                    copy[key] = val[key].concat();
+                }
+            }
+        }
+        return copy;
+    },
+
+    /**
+     * Sets the marker plane for the series when the coords argument is an array.
+     * If the coords argument is an object literal no marker plane is set.
+     *
+     * @method _setXMarkerPlane
+     * @param {Array|Object} coords An array of x coordinates or an object literal
+     * containing key value pairs mapped to an array of coordinates.
+     * @param {Number} dataLength The length of data for the series.
+     * @private
+     */
+    _setXMarkerPlane: function(coords, dataLength)
+    {
+        var i = 0,
+            xMarkerPlane = [],
+            xMarkerPlaneOffset = this.get("xMarkerPlaneOffset"),
+            nextX;
+        if(Y_Lang.isArray(coords))
+        {
+            for(i = 0; i < dataLength; i = i + 1)
+            {
+                nextX = coords[i];
+                xMarkerPlane.push({start:nextX - xMarkerPlaneOffset, end: nextX + xMarkerPlaneOffset});
+            }
+            this.set("xMarkerPlane", xMarkerPlane);
+        }
+    },
+
+    /**
+     * Sets the marker plane for the series when the coords argument is an array.
+     * If the coords argument is an object literal no marker plane is set.
+     *
+     * @method _setYMarkerPlane
+     * @param {Array|Object} coords An array of y coordinates or an object literal
+     * containing key value pairs mapped to an array of coordinates.
+     * @param {Number} dataLength The length of data for the series.
+     * @private
+     */
+    _setYMarkerPlane: function(coords, dataLength)
+    {
+        var i = 0,
+            yMarkerPlane = [],
+            yMarkerPlaneOffset = this.get("yMarkerPlaneOffset"),
+            nextY;
+        if(Y_Lang.isArray(coords))
+        {
+            for(i = 0; i < dataLength; i = i + 1)
+            {
+                nextY = coords[i];
+                yMarkerPlane.push({start:nextY - yMarkerPlaneOffset, end: nextY + yMarkerPlaneOffset});
+            }
+            this.set("yMarkerPlane", yMarkerPlane);
+        }
+    },
+
+    /**
+     * Finds the first valid index of an array coordinates.
+     *
+     * @method _getFirstValidIndex
+     * @param {Array} coords An array of x or y coordinates.
+     * @return Number
+     * @private
+     */
+    _getFirstValidIndex: function(coords)
+    {
+        var coord,
+            i = -1,
+            limit = coords.length;
+        while(!Y_Lang.isNumber(coord) && i < limit)
+        {
+            i += 1;
+            coord = coords[i];
+        }
+        return i;
+    },
+
+    /**
+     * Finds the last valid index of an array coordinates.
+     *
+     * @method _getLastValidIndex
+     * @param {Array} coords An array of x or y coordinates.
+     * @return Number
+     * @private
+     */
+    _getLastValidIndex: function(coords)
+    {
+        var coord,
+            i = coords.length,
+            limit = -1;
+        while(!Y_Lang.isNumber(coord) && i > limit)
+        {
+            i -= 1;
+            coord = coords[i];
+        }
+        return i;
+    },
+
+    /**
+     * Draws the series.
+     *
+     * @method draw
+     * @protected
+     */
+    draw: function()
+    {
+        var w = this.get("width"),
+            h = this.get("height"),
+            xcoords,
+            ycoords;
+        if(this.get("rendered"))
+        {
+            if((isFinite(w) && isFinite(h) && w > 0 && h > 0) &&
+                ((this.get("xData") && this.get("yData")) ||
+                this._updateAxisBase()))
+            {
+                if(this._drawing)
+                {
+                    this._callLater = true;
+                    return;
+                }
+                this._drawing = true;
+                this._callLater = false;
+                this.setAreaData();
+                xcoords = this.get("xcoords");
+                ycoords = this.get("ycoords");
+                if(xcoords && ycoords && xcoords.length > 0)
+                {
+                    this.drawSeries();
+                }
+                this._drawing = false;
+                if(this._callLater)
+                {
+                    this.draw();
+                }
+                else
+                {
+                    this._toggleVisible(this.get("visible"));
+                    this.fire("drawingComplete");
+                }
+            }
+        }
+    },
+
+    /**
+     * Default value for plane offsets when the parent chart's `interactiveType` is `planar`.
+     *
+     * @property _defaultPlaneOffset
+     * @type Number
+     * @private
+     */
+    _defaultPlaneOffset: 4,
+
+    /**
+     * Destructor implementation for the CartesianSeries class.
+     * Calls destroy on all Graphic instances.
+     *
+     * @method destructor
+     * @protected
+     */
+    destructor: function()
+    {
+        if(this.get("rendered"))
+        {
+            if(this._xDataReadyHandle)
+            {
+                this._xDataReadyHandle.detach();
+            }
+            if(this._xDataUpdateHandle)
+            {
+                this._xDataUpdateHandle.detach();
+            }
+            if(this._yDataReadyHandle)
+            {
+                this._yDataReadyHandle.detach();
+            }
+            if(this._yDataUpdateHandle)
+            {
+                this._yDataUpdateHandle.detach();
+            }
+            if(this._xAxisChangeHandle)
+            {
+                this._xAxisChangeHandle.detach();
+            }
+            if(this._yAxisChangeHandle)
+            {
+                this._yAxisChangeHandle.detach();
+            }
+        }
+    }
+        /**
+         * Event handle for the x-axis' dataReady event.
+         *
+         * @property _xDataReadyHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the x-axis dataUpdate event.
+         *
+         * @property _xDataUpdateHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the y-axis dataReady event.
+         *
+         * @property _yDataReadyHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the y-axis dataUpdate event.
+         * @property _yDataUpdateHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the xAxisChange event.
+         * @property _xAxisChangeHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the yAxisChange event.
+         * @property _yAxisChangeHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the stylesChange event.
+         * @property _stylesChangeHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the widthChange event.
+         * @property _widthChangeHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the heightChange event.
+         * @property _heightChangeHandle
+         * @type {EventHandle}
+         * @private
+         */
+
+        /**
+         * Event handle for the visibleChange event.
+         * @property _visibleChangeHandle
+         * @type {EventHandle}
+         * @private
+         */
+}, {
+    ATTRS: {
+        /**
+         * An array of all series of the same type used within a chart application.
+         *
+         * @attribute seriesTypeCollection
+         * @type Array
+         */
+        seriesTypeCollection: {},
+
+        /**
+         * Name used for for displaying data related to the x-coordinate.
+         *
+         * @attribute xDisplayName
+         * @type String
+         */
+        xDisplayName: {
+            getter: function()
+            {
+                return this._xDisplayName || this.get("xKey");
+            },
+
+            setter: function(val)
+            {
+                this._xDisplayName = val.toString();
+                return val;
+            }
+        },
+
+        /**
+         * Name used for for displaying data related to the y-coordinate.
+         *
+         * @attribute yDisplayName
+         * @type String
+         */
+        yDisplayName: {
+            getter: function()
+            {
+                return this._yDisplayName || this.get("yKey");
+            },
+
+            setter: function(val)
+            {
+                this._yDisplayName = val.toString();
+                return val;
+            }
+        },
+
+        /**
+         * Name used for for displaying category data
+         *
+         * @attribute categoryDisplayName
+         * @type String
+         * @readOnly
+         */
+        categoryDisplayName: {
+            lazyAdd: false,
+
+            getter: function()
+            {
+                return this.get("direction") === "vertical" ? this.get("yDisplayName") : this.get("xDisplayName");
+            },
+
+            setter: function(val)
+            {
+                if(this.get("direction") === "vertical")
+                {
+                    this._yDisplayName = val;
+                }
+                else
+                {
+                    this._xDisplayName = val;
+                }
+                return val;
+            }
+        },
+
+        /**
+         * Name used for for displaying value data
+         *
+         * @attribute valueDisplayName
+         * @type String
+         * @readOnly
+         */
+        valueDisplayName: {
+            lazyAdd: false,
+
+            getter: function()
+            {
+                return this.get("direction") === "vertical" ? this.get("xDisplayName") : this.get("yDisplayName");
+            },
+
+            setter: function(val)
+            {
+                if(this.get("direction") === "vertical")
+                {
+                    this._xDisplayName = val;
+                }
+                else
+                {
+                    this._yDisplayName = val;
+                }
+                return val;
+            }
+        },
+
+        /**
+         * Read-only attribute indicating the type of series.
+         *
+         * @attribute type
+         * @type String
+         * @default cartesian
+         */
+        type: {
+            value: "cartesian"
+        },
+
+        /**
+         * Order of this instance of this `type`.
+         *
+         * @attribute order
+         * @type Number
+         */
+        order: {},
+
+        /**
+         * Order of the instance
+         *
+         * @attribute graphOrder
+         * @type Number
+         */
+        graphOrder: {},
+
+        /**
+         * x coordinates for the series.
+         *
+         * @attribute xcoords
+         * @type Array
+         */
+        xcoords: {},
+
+        /**
+         * y coordinates for the series
+         *
+         * @attribute ycoords
+         * @type Array
+         */
+        ycoords: {},
+
+        /**
+         * Reference to the `Axis` instance used for assigning
+         * x-values to the graph.
+         *
+         * @attribute xAxis
+         * @type Axis
+         */
+        xAxis: {},
+
+        /**
+         * Reference to the `Axis` instance used for assigning
+         * y-values to the graph.
+         *
+         * @attribute yAxis
+         * @type Axis
+         */
+        yAxis: {},
+
+        /**
+         * Indicates which array to from the hash of value arrays in
+         * the x-axis `Axis` instance.
+         *
+         * @attribute xKey
+         * @type String
+         */
+        xKey: {
+            setter: function(val)
+            {
+                if(Y_Lang.isArray(val))
+                {
+                    return val;
+                }
+                else
+                {
+                    return val.toString();
+                }
+            }
+        },
+
+        /**
+         * Indicates which array to from the hash of value arrays in
+         * the y-axis `Axis` instance.
+         *
+         * @attribute yKey
+         * @type String
+         */
+        yKey: {
+            setter: function(val)
+            {
+                if(Y_Lang.isArray(val))
+                {
+                    return val;
+                }
+                else
+                {
+                    return val.toString();
+                }
+            }
+        },
+
+        /**
+         * Array of x values for the series.
+         *
+         * @attribute xData
+         * @type Array
+         */
+        xData: {},
+
+        /**
+         * Array of y values for the series.
+         *
+         * @attribute yData
+         * @type Array
+         */
+        yData: {},
+
+        /**
+         * Collection of area maps along the xAxis. Used to determine mouseover for multiple
+         * series.
+         *
+         * @attribute xMarkerPlane
+         * @type Array
+         */
+        xMarkerPlane: {},
+
+        /**
+         * Collection of area maps along the yAxis. Used to determine mouseover for multiple
+         * series.
+         *
+         * @attribute yMarkerPlane
+         * @type Array
+         */
+        yMarkerPlane: {},
+
+        /**
+         * Distance from a data coordinate to the left/right for setting a hotspot.
+         *
+         * @attribute xMarkerPlaneOffset
+         * @type Number
+         */
+        xMarkerPlaneOffset: {
+            getter: function() {
+                var marker = this.get("styles").marker;
+                if(marker && marker.width && isFinite(marker.width))
+                {
+                    return marker.width * 0.5;
+                }
+                return this._defaultPlaneOffset;
+            }
+        },
+
+        /**
+         * Distance from a data coordinate to the top/bottom for setting a hotspot.
+         *
+         * @attribute yMarkerPlaneOffset
+         * @type Number
+         */
+        yMarkerPlaneOffset: {
+            getter: function() {
+                var marker = this.get("styles").marker;
+                if(marker && marker.height && isFinite(marker.height))
+                {
+                    return marker.height * 0.5;
+                }
+                return this._defaultPlaneOffset;
+            }
+        },
+
+        /**
+         * Direction of the series
+         *
+         * @attribute direction
+         * @type String
+         */
+        direction: {
+            value: "horizontal"
+        }
+    }
+});
+
+
+}, '@VERSION@', {"requires": ["series-base"]});