aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/parts-gantt/CurrentDateIndicator.js

@@ -0,0 +1,100 @@
+/* *
+ *
+ *  (c) 2016-2019 Highsoft AS
+ *
+ *  Author: Lars A. V. Cabrera
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+
+var addEvent = H.addEvent,
+    Axis = H.Axis,
+    PlotLineOrBand = H.PlotLineOrBand,
+    merge = H.merge;
+
+var defaultConfig = {
+    /**
+     * Show an indicator on the axis for the current date and time. Can be a
+     * boolean or a configuration object similar to
+     * [xAxis.plotLines](#xAxis.plotLines).
+     *
+     * @sample gantt/current-date-indicator/demo
+     *         Current date indicator enabled
+     * @sample gantt/current-date-indicator/object-config
+     *         Current date indicator with custom options
+     *
+     * @type      {boolean|*}
+     * @default   true
+     * @extends   xAxis.plotLines
+     * @excluding value
+     * @product   gantt
+     * @apioption xAxis.currentDateIndicator
+     */
+    currentDateIndicator: true,
+    color: '#ccd6eb',
+    width: 2,
+    label: {
+        format: '%a, %b %d %Y, %H:%M',
+        formatter: undefined,
+        rotation: 0,
+        style: {
+            fontSize: '10px'
+        }
+    }
+};
+
+addEvent(Axis, 'afterSetOptions', function () {
+    var options = this.options,
+        cdiOptions = options.currentDateIndicator;
+
+    if (cdiOptions) {
+        if (typeof cdiOptions === 'object') {
+            // Ignore formatter if custom format is defined
+            if (cdiOptions.label && cdiOptions.label.format) {
+                cdiOptions.label.formatter = undefined;
+            }
+            cdiOptions = merge(defaultConfig, cdiOptions);
+        } else {
+            cdiOptions = merge(defaultConfig);
+        }
+
+        cdiOptions.value = new Date();
+
+        if (!options.plotLines) {
+            options.plotLines = [];
+        }
+
+        options.plotLines.push(cdiOptions);
+    }
+
+});
+
+addEvent(PlotLineOrBand, 'render', function () {
+    var options = this.options,
+        format,
+        formatter;
+
+    if (options.currentDateIndicator && options.label) {
+        format = options.label.format;
+        formatter = options.label.formatter;
+
+        options.value = new Date();
+        if (typeof formatter === 'function') {
+            options.label.text = formatter(this);
+        } else {
+            options.label.text = H.dateFormat(format, new Date());
+        }
+
+        // If the label already exists, update its text
+        if (this.label) {
+            this.label.attr({
+                text: options.label.text
+            });
+        }
+    }
+});

data/vendor/assets/javascripts/highstock/es-modules/parts-gantt/GanttChart.js

@@ -0,0 +1,140 @@
+/* *
+ * (c) 2016 Highsoft AS
+ * Authors: Lars A. V. Cabrera
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import './GanttSeries';
+
+var merge = H.merge,
+    splat = H.splat,
+    Chart = H.Chart;
+
+/**
+ * Factory function for Gantt charts.
+ *
+ * @example
+ * // Render a chart in to div#container
+ * var chart = Highcharts.ganttChart('container', {
+ *     title: {
+ *         text: 'My chart'
+ *     },
+ *     series: [{
+ *         data: ...
+ *     }]
+ * });
+ *
+ * @function Highcharts.ganttChart
+ *
+ * @param {string|Highcharts.HTMLDOMElement} [renderTo]
+ *        The DOM element to render to, or its id.
+ *
+ * @param {Highcharts.Options} options
+ *        The chart options structure.
+ *
+ * @param {Highcharts.ChartCallbackFunction} [callback]
+ *        Function to run when the chart has loaded and and all external images
+ *        are loaded. Defining a
+ *        [chart.events.load](https://api.highcharts.com/highcharts/chart.events.load)
+ *        handler is equivalent.
+ *
+ * @return {Highcharts.Chart}
+ *         Returns the Chart object.
+ */
+H.ganttChart = function (renderTo, options, callback) {
+    var hasRenderToArg = typeof renderTo === 'string' || renderTo.nodeName,
+        seriesOptions = options.series,
+        defaultOptions = H.getOptions(),
+        defaultLinkedTo,
+        userOptions = options;
+
+    options = arguments[hasRenderToArg ? 1 : 0];
+
+    // If user hasn't defined axes as array, make it into an array and add a
+    // second axis by default.
+    if (!H.isArray(options.xAxis)) {
+        options.xAxis = [options.xAxis || {}, {}];
+    }
+
+    // apply X axis options to both single and multi x axes
+    options.xAxis = options.xAxis.map(function (xAxisOptions, i) {
+        if (i === 1) { // Second xAxis
+            defaultLinkedTo = 0;
+        }
+        return merge(
+            defaultOptions.xAxis,
+            { // defaults
+                grid: {
+                    enabled: true
+                },
+                opposite: true,
+                linkedTo: defaultLinkedTo
+            },
+            xAxisOptions, // user options
+            { // forced options
+                type: 'datetime'
+            }
+        );
+    });
+
+    // apply Y axis options to both single and multi y axes
+    options.yAxis = (splat(options.yAxis || {})).map(function (yAxisOptions) {
+        return merge(
+            defaultOptions.yAxis, // #3802
+            { // defaults
+                grid: {
+                    enabled: true
+                },
+
+                staticScale: 50,
+
+                reversed: true,
+
+                // Set default type treegrid, but only if 'categories' is
+                // undefined
+                type: yAxisOptions.categories ? yAxisOptions.type : 'treegrid'
+            },
+            yAxisOptions // user options
+        );
+    });
+
+    options.series = null;
+
+    options = merge(
+        true,
+        {
+            chart: {
+                type: 'gantt'
+            },
+            title: {
+                text: null
+            },
+            legend: {
+                enabled: false
+            }
+        },
+
+        options, // user's options
+
+        // forced options
+        {
+            isGantt: true
+        }
+    );
+
+    options.series = userOptions.series = seriesOptions;
+
+    options.series.forEach(function (series) {
+        series.data.forEach(function (point) {
+            H.seriesTypes.gantt.prototype.setGanttPointAliases(point);
+        });
+    });
+
+    return hasRenderToArg ?
+        new Chart(renderTo, options, callback) :
+        new Chart(options, options);
+};

data/vendor/assets/javascripts/highstock/es-modules/parts-gantt/GanttSeries.js

@@ -0,0 +1,415 @@
+/* *
+ *
+ *  (c) 2016-2019 Highsoft AS
+ *
+ *  Author: Lars A. V. Cabrera
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import './CurrentDateIndicator';
+import 'GridAxis.js';
+import '../modules/static-scale.src.js';
+import 'TreeGrid.js';
+import 'Pathfinder.js';
+import '../modules/xrange.src.js';
+
+var dateFormat = H.dateFormat,
+    isObject = H.isObject,
+    isNumber = H.isNumber,
+    merge = H.merge,
+    pick = H.pick,
+    seriesType = H.seriesType,
+    seriesTypes = H.seriesTypes,
+    stop = H.stop,
+    Series = H.Series,
+    parent = seriesTypes.xrange;
+
+/**
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.gantt
+ *
+ * @augments Highcharts.Series
+ */
+seriesType('gantt', 'xrange'
+
+    /**
+ * A `gantt` series. If the [type](#series.gantt.type) option is not specified,
+ * it is inherited from [chart.type](#chart.type).
+ *
+ * @extends      plotOptions.xrange
+ * @product      gantt
+ * @optionparent plotOptions.gantt
+ */
+    , {
+    // options - default options merged with parent
+
+        grouping: false,
+
+        dataLabels: {
+            enabled: true,
+            formatter: function () {
+                var point = this,
+                    amount = point.point.partialFill;
+
+                if (isObject(amount)) {
+                    amount = amount.amount;
+                }
+                if (isNumber(amount) && amount > 0) {
+                    return (amount * 100) + '%';
+                }
+            }
+        },
+        tooltip: {
+            headerFormat: '<span style="font-size: 10px">{series.name}</span><br/>',
+            pointFormat: null,
+            pointFormatter: function () {
+                var point = this,
+                    series = point.series,
+                    tooltip = series.chart.tooltip,
+                    xAxis = series.xAxis,
+                    options = xAxis.options,
+                    formats = options.dateTimeLabelFormats,
+                    startOfWeek = xAxis.options.startOfWeek,
+                    ttOptions = series.tooltipOptions,
+                    format = ttOptions.xDateFormat,
+                    range = point.end ? point.end - point.start : 0,
+                    start,
+                    end,
+                    milestone = point.options.milestone,
+                    retVal = '<b>' + (point.name || point.yCategory) + '</b>';
+
+                if (ttOptions.pointFormat) {
+                    return point.tooltipFormatter(ttOptions.pointFormat);
+                }
+
+                if (!format) {
+                    format = H.splat(
+                        tooltip.getDateFormat(
+                            range,
+                            point.start,
+                            startOfWeek,
+                            formats
+                        )
+                    )[0];
+                }
+
+                start = dateFormat(format, point.start);
+                end = dateFormat(format, point.end);
+
+                retVal += '<br/>';
+
+                if (!milestone) {
+                    retVal += 'Start: ' + start + '<br/>';
+                    retVal += 'End: ' + end + '<br/>';
+                } else {
+                    retVal += 'Date ' + start + '<br/>';
+                }
+
+                return retVal;
+            }
+        },
+        connectors: {
+            type: 'simpleConnect',
+            animation: {
+                reversed: true // Dependencies go from child to parent
+            },
+            startMarker: {
+                enabled: true,
+                symbol: 'arrow-filled',
+                radius: 4,
+                fill: '#fa0',
+                align: 'left'
+            },
+            endMarker: {
+                enabled: false, // Only show arrow on the dependent task
+                align: 'right'
+            }
+        }
+    }, {
+    // props - series member overrides
+
+        pointArrayMap: ['start', 'end', 'y'],
+
+        // Keyboard navigation, don't use nearest vertical mode
+        keyboardMoveVertical: false,
+
+        // Handle milestones, as they have no x2
+        translatePoint: function (point) {
+            var series = this,
+                shapeArgs,
+                size;
+
+            parent.prototype.translatePoint.call(series, point);
+
+            if (point.options.milestone) {
+                shapeArgs = point.shapeArgs;
+                size = shapeArgs.height;
+                point.shapeArgs = {
+                    x: shapeArgs.x - (size / 2),
+                    y: shapeArgs.y,
+                    width: size,
+                    height: size
+                };
+            }
+        },
+
+        /**
+     * Draws a single point in the series.
+     *
+     * This override draws the point as a diamond if point.options.milestone is
+     * true, and uses the original drawPoint() if it is false or not set.
+     *
+     * @requires module:highcharts-gantt
+     *
+     * @private
+     * @function Highcharts.seriesTypes.gantt#drawPoint
+     *
+     * @param {Highcharts.Point} point
+     *        An instance of Point in the series
+     *
+     * @param {"animate"|"attr"} verb
+     *        'animate' (animates changes) or 'attr' (sets options)
+     */
+        drawPoint: function (point, verb) {
+            var series = this,
+                seriesOpts = series.options,
+                renderer = series.chart.renderer,
+                shapeArgs = point.shapeArgs,
+                plotY = point.plotY,
+                graphic = point.graphic,
+                state = point.selected && 'select',
+                cutOff = seriesOpts.stacking && !seriesOpts.borderRadius,
+                diamondShape;
+
+            if (point.options.milestone) {
+                if (isNumber(plotY) && point.y !== null) {
+                    diamondShape = renderer.symbols.diamond(
+                        shapeArgs.x,
+                        shapeArgs.y,
+                        shapeArgs.width,
+                        shapeArgs.height
+                    );
+
+                    if (graphic) {
+                        stop(graphic);
+                        graphic[verb]({
+                            d: diamondShape
+                        });
+                    } else {
+                        point.graphic = graphic = renderer.path(diamondShape)
+                            .addClass(point.getClassName(), true)
+                            .add(point.group || series.group);
+                    }
+
+                    // Presentational
+                    if (!series.chart.styledMode) {
+                        point.graphic
+                            .attr(series.pointAttribs(point, state))
+                            .shadow(seriesOpts.shadow, null, cutOff);
+                    }
+                } else if (graphic) {
+                    point.graphic = graphic.destroy(); // #1269
+                }
+            } else {
+                parent.prototype.drawPoint.call(series, point, verb);
+            }
+        },
+
+        setData: Series.prototype.setData,
+
+        setGanttPointAliases: function (options) {
+        // Add a value to options if the value exists
+            function addIfExists(prop, val) {
+                if (val !== undefined) {
+                    options[prop] = val;
+                }
+            }
+            addIfExists('x', pick(options.start, options.x));
+            addIfExists('x2', pick(options.end, options.x2));
+            addIfExists(
+                'partialFill', pick(options.completed, options.partialFill)
+            );
+            addIfExists('connect', pick(options.dependency, options.connect));
+        }
+
+    }, merge(parent.prototype.pointClass.prototype, {
+    // pointProps - point member overrides. We inherit from parent as well.
+    /**
+     * Applies the options containing the x and y data and possible some extra
+     * properties. This is called on point init or from point.update.
+     *
+     * @private
+     * @function Highcharts.Point#applyOptions
+     *
+     * @param {object} options
+     *        The point options
+     *
+     * @param {number} x
+     *        The x value
+     *
+     * @return {Highcharts.Point}
+     *         The Point instance
+     */
+        applyOptions: function (options, x) {
+            var point = this,
+                retVal = merge(options);
+
+            H.seriesTypes.gantt.prototype.setGanttPointAliases(retVal);
+
+            retVal = parent.prototype.pointClass.prototype.applyOptions
+                .call(point, retVal, x);
+            return retVal;
+        }
+    }));
+
+/**
+ * A `gantt` series.
+ *
+ * @extends   series,plotOptions.gantt
+ * @excluding boostThreshold, connectors, dashStyle, findNearestPointBy,
+ *            getExtremesFromAll, marker, negativeColor, pointInterval,
+ *            pointIntervalUnit, pointPlacement, pointStart
+ * @product   gantt
+ * @apioption series.gantt
+ */
+
+/**
+ * Data for a Gantt series.
+ *
+ * @type      {Array<*>}
+ * @extends   series.xrange.data
+ * @excluding className, color, colorIndex, connect, dataLabels, events, id,
+ *            partialFill, selected, x, x2
+ * @product   gantt
+ * @apioption series.gantt.data
+ */
+
+/**
+ * Whether the grid node belonging to this point should start as collapsed. Used
+ * in axes of type treegrid.
+ *
+ * @sample {gantt} gantt/treegrid-axis/collapsed/
+ *         Start as collapsed
+ *
+ * @type      {boolean}
+ * @default   false
+ * @product   gantt
+ * @apioption series.gantt.data.collapsed
+ */
+
+/**
+ * The start time of a task.
+ *
+ * @type      {number}
+ * @product   gantt
+ * @apioption series.gantt.data.start
+ */
+
+/**
+ * The end time of a task.
+ *
+ * @type      {number}
+ * @product   gantt
+ * @apioption series.gantt.data.end
+ */
+
+/**
+ * The Y value of a task.
+ *
+ * @type      {number}
+ * @product   gantt
+ * @apioption series.gantt.data.y
+ */
+
+/**
+ * The name of a task. If a `treegrid` y-axis is used (default in Gantt charts),
+ * this will be picked up automatically, and used to calculate the y-value.
+ *
+ * @type      {string}
+ * @product   gantt
+ * @apioption series.gantt.data.name
+ */
+
+/**
+ * Progress indicator, how much of the task completed. If it is a number, the
+ * `fill` will be applied automatically.
+ *
+ * @sample {gantt} gantt/demo/progress-indicator
+ *         Progress indicator
+ *
+ * @type      {number|*}
+ * @extends   series.xrange.data.partialFill
+ * @product   gantt
+ * @apioption series.gantt.data.completed
+ */
+
+/**
+ * The amount of the progress indicator, ranging from 0 (not started) to 1
+ * (finished).
+ *
+ * @type      {number}
+ * @default   0
+ * @apioption series.gantt.data.completed.amount
+ */
+
+/**
+ * The fill of the progress indicator. Defaults to a darkened variety of the
+ * main color.
+ *
+ * @type      {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
+ * @apioption series.gantt.data.completed.fill
+ */
+
+/**
+ * The ID of the point (task) that this point depends on in Gantt charts.
+ * Aliases [connect](series.xrange.data.connect). Can also be an object,
+ * specifying further connecting [options](series.gantt.connectors) between the
+ * points. Multiple connections can be specified by providing an array.
+ *
+ * @sample gantt/demo/project-management
+ *         Dependencies
+ * @sample gantt/pathfinder/demo
+ *         Different connection types
+ *
+ * @type      {string|Array<string|*>|*}
+ * @extends   series.xrange.data.connect
+ * @since     6.2.0
+ * @product   gantt
+ * @apioption series.gantt.data.dependency
+ */
+
+/**
+ * Whether this point is a milestone. If so, only the `start` option is handled,
+ * while `end` is ignored.
+ *
+ * @sample gantt/gantt/milestones
+ *         Milestones
+ *
+ * @type      {boolean}
+ * @since     6.2.0
+ * @product   gantt
+ * @apioption series.gantt.data.milestone
+ */
+
+/**
+ * The ID of the parent point (task) of this point in Gantt charts.
+ *
+ * @sample gantt/demo/subtasks
+ *         Gantt chart with subtasks
+ *
+ * @type      {string}
+ * @since     6.2.0
+ * @product   gantt
+ * @apioption series.gantt.data.parent
+ */
+
+/**
+ * @excluding afterAnimate
+ * @apioption series.gantt.events
+ */