ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Annotations/Controllables/ControllableLabel.js

@@ -0,0 +1,387 @@
+/* *
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Imports
+ *
+ * */
+import '../../../Core/Renderer/SVG/SVGRenderer.js';
+import ControllableMixin from '../Mixins/ControllableMixin.js';
+import F from '../../../Core/FormatUtilities.js';
+var format = F.format;
+import MockPoint from '../MockPoint.js';
+import SVGRenderer from '../../../Core/Renderer/SVG/SVGRenderer.js';
+var symbols = SVGRenderer.prototype.symbols;
+import Tooltip from '../../../Core/Tooltip.js';
+import U from '../../../Core/Utilities.js';
+var extend = U.extend, isNumber = U.isNumber, pick = U.pick;
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * A controllable label class.
+ *
+ * @requires modules/annotations
+ *
+ * @private
+ * @class
+ * @name Highcharts.AnnotationControllableLabel
+ *
+ * @param {Highcharts.Annotation} annotation
+ * An annotation instance.
+ * @param {Highcharts.AnnotationsLabelOptions} options
+ * A label's options.
+ * @param {number} index
+ * Index of the label.
+ */
+var ControllableLabel = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function ControllableLabel(annotation, options, index) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.addControlPoints = ControllableMixin.addControlPoints;
+        this.attr = ControllableMixin.attr;
+        this.attrsFromOptions = ControllableMixin.attrsFromOptions;
+        this.destroy = ControllableMixin.destroy;
+        this.getPointsOptions = ControllableMixin.getPointsOptions;
+        this.init = ControllableMixin.init;
+        this.linkPoints = ControllableMixin.linkPoints;
+        this.point = ControllableMixin.point;
+        this.rotate = ControllableMixin.rotate;
+        this.scale = ControllableMixin.scale;
+        this.setControlPointsVisibility = (ControllableMixin.setControlPointsVisibility);
+        this.shouldBeDrawn = ControllableMixin.shouldBeDrawn;
+        this.transform = ControllableMixin.transform;
+        this.transformPoint = ControllableMixin.transformPoint;
+        this.translateShape = ControllableMixin.translateShape;
+        this.update = ControllableMixin.update;
+        this.init(annotation, options, index);
+        this.collection = 'labels';
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * Returns new aligned position based alignment options and box to align to.
+     * It is almost a one-to-one copy from SVGElement.prototype.align
+     * except it does not use and mutate an element
+     *
+     * @param {Highcharts.AnnotationAlignObject} alignOptions
+     *
+     * @param {Highcharts.BBoxObject} box
+     *
+     * @return {Highcharts.PositionObject}
+     * Aligned position.
+     */
+    ControllableLabel.alignedPosition = function (alignOptions, box) {
+        var align = alignOptions.align, vAlign = alignOptions.verticalAlign;
+        var x = (box.x || 0) + (alignOptions.x || 0), y = (box.y || 0) + (alignOptions.y || 0), alignFactor, vAlignFactor;
+        if (align === 'right') {
+            alignFactor = 1;
+        }
+        else if (align === 'center') {
+            alignFactor = 2;
+        }
+        if (alignFactor) {
+            x += (box.width - (alignOptions.width || 0)) / alignFactor;
+        }
+        if (vAlign === 'bottom') {
+            vAlignFactor = 1;
+        }
+        else if (vAlign === 'middle') {
+            vAlignFactor = 2;
+        }
+        if (vAlignFactor) {
+            y += (box.height - (alignOptions.height || 0)) / vAlignFactor;
+        }
+        return {
+            x: Math.round(x),
+            y: Math.round(y)
+        };
+    };
+    /**
+     * Returns new alignment options for a label if the label is outside the
+     * plot area. It is almost a one-to-one copy from
+     * Series.prototype.justifyDataLabel except it does not mutate the label and
+     * it works with absolute instead of relative position.
+     */
+    ControllableLabel.justifiedOptions = function (chart, label, alignOptions, alignAttr) {
+        var align = alignOptions.align, verticalAlign = alignOptions.verticalAlign, padding = label.box ? 0 : (label.padding || 0), bBox = label.getBBox(), 
+        //
+        options = {
+            align: align,
+            verticalAlign: verticalAlign,
+            x: alignOptions.x,
+            y: alignOptions.y,
+            width: label.width,
+            height: label.height
+        }, 
+        //
+        x = (alignAttr.x || 0) - chart.plotLeft, y = (alignAttr.y || 0) - chart.plotTop;
+        var off;
+        // Off left
+        off = x + padding;
+        if (off < 0) {
+            if (align === 'right') {
+                options.align = 'left';
+            }
+            else {
+                options.x = (options.x || 0) - off;
+            }
+        }
+        // Off right
+        off = x + bBox.width - padding;
+        if (off > chart.plotWidth) {
+            if (align === 'left') {
+                options.align = 'right';
+            }
+            else {
+                options.x = (options.x || 0) + chart.plotWidth - off;
+            }
+        }
+        // Off top
+        off = y + padding;
+        if (off < 0) {
+            if (verticalAlign === 'bottom') {
+                options.verticalAlign = 'top';
+            }
+            else {
+                options.y = (options.y || 0) - off;
+            }
+        }
+        // Off bottom
+        off = y + bBox.height - padding;
+        if (off > chart.plotHeight) {
+            if (verticalAlign === 'top') {
+                options.verticalAlign = 'bottom';
+            }
+            else {
+                options.y = (options.y || 0) + chart.plotHeight - off;
+            }
+        }
+        return options;
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Translate the point of the label by deltaX and deltaY translations.
+     * The point is the label's anchor.
+     *
+     * @param {number} dx translation for x coordinate
+     * @param {number} dy translation for y coordinate
+     */
+    ControllableLabel.prototype.translatePoint = function (dx, dy) {
+        ControllableMixin.translatePoint.call(this, dx, dy, 0);
+    };
+    /**
+     * Translate x and y position relative to the label's anchor.
+     *
+     * @param {number} dx translation for x coordinate
+     * @param {number} dy translation for y coordinate
+     */
+    ControllableLabel.prototype.translate = function (dx, dy) {
+        var chart = this.annotation.chart, 
+        // Annotation.options
+        labelOptions = this.annotation.userOptions, 
+        // Chart.options.annotations
+        annotationIndex = chart.annotations.indexOf(this.annotation), chartAnnotations = chart.options.annotations, chartOptions = chartAnnotations[annotationIndex];
+        if (chart.inverted) {
+            var temp = dx;
+            dx = dy;
+            dy = temp;
+        }
+        // Local options:
+        this.options.x += dx;
+        this.options.y += dy;
+        // Options stored in chart:
+        chartOptions[this.collection][this.index].x = this.options.x;
+        chartOptions[this.collection][this.index].y = this.options.y;
+        labelOptions[this.collection][this.index].x = this.options.x;
+        labelOptions[this.collection][this.index].y = this.options.y;
+    };
+    ControllableLabel.prototype.render = function (parent) {
+        var options = this.options, attrs = this.attrsFromOptions(options), style = options.style;
+        this.graphic = this.annotation.chart.renderer
+            .label('', 0, -9999, // #10055
+        options.shape, null, null, options.useHTML, null, 'annotation-label')
+            .attr(attrs)
+            .add(parent);
+        if (!this.annotation.chart.styledMode) {
+            if (style.color === 'contrast') {
+                style.color = this.annotation.chart.renderer.getContrast(ControllableLabel.shapesWithoutBackground.indexOf(options.shape) > -1 ? '#FFFFFF' : options.backgroundColor);
+            }
+            this.graphic
+                .css(options.style)
+                .shadow(options.shadow);
+        }
+        if (options.className) {
+            this.graphic.addClass(options.className);
+        }
+        this.graphic.labelrank = options.labelrank;
+        ControllableMixin.render.call(this);
+    };
+    ControllableLabel.prototype.redraw = function (animation) {
+        var options = this.options, text = this.text || options.format || options.text, label = this.graphic, point = this.points[0];
+        label.attr({
+            text: text ?
+                format(text, point.getLabelConfig(), this.annotation.chart) :
+                options.formatter.call(point, this)
+        });
+        var anchor = this.anchor(point);
+        var attrs = this.position(anchor);
+        if (attrs) {
+            label.alignAttr = attrs;
+            attrs.anchorX = anchor.absolutePosition.x;
+            attrs.anchorY = anchor.absolutePosition.y;
+            label[animation ? 'animate' : 'attr'](attrs);
+        }
+        else {
+            label.attr({
+                x: 0,
+                y: -9999 // #10055
+            });
+        }
+        label.placed = !!attrs;
+        ControllableMixin.redraw.call(this, animation);
+    };
+    /**
+     * All basic shapes don't support alignTo() method except label.
+     * For a controllable label, we need to subtract translation from
+     * options.
+     */
+    ControllableLabel.prototype.anchor = function (_point) {
+        var anchor = ControllableMixin.anchor.apply(this, arguments), x = this.options.x || 0, y = this.options.y || 0;
+        anchor.absolutePosition.x -= x;
+        anchor.absolutePosition.y -= y;
+        anchor.relativePosition.x -= x;
+        anchor.relativePosition.y -= y;
+        return anchor;
+    };
+    /**
+     * Returns the label position relative to its anchor.
+     */
+    ControllableLabel.prototype.position = function (anchor) {
+        var item = this.graphic, chart = this.annotation.chart, point = this.points[0], itemOptions = this.options, anchorAbsolutePosition = anchor.absolutePosition, anchorRelativePosition = anchor.relativePosition;
+        var itemPosition, alignTo, itemPosRelativeX, itemPosRelativeY, showItem = point.series.visible &&
+            MockPoint.prototype.isInsidePlot.call(point);
+        var _a = item.width, width = _a === void 0 ? 0 : _a, _b = item.height, height = _b === void 0 ? 0 : _b;
+        if (showItem) {
+            if (itemOptions.distance) {
+                itemPosition = Tooltip.prototype.getPosition.call({
+                    chart: chart,
+                    distance: pick(itemOptions.distance, 16)
+                }, width, height, {
+                    plotX: anchorRelativePosition.x,
+                    plotY: anchorRelativePosition.y,
+                    negative: point.negative,
+                    ttBelow: point.ttBelow,
+                    h: (anchorRelativePosition.height ||
+                        anchorRelativePosition.width)
+                });
+            }
+            else if (itemOptions.positioner) {
+                itemPosition = itemOptions.positioner.call(this);
+            }
+            else {
+                alignTo = {
+                    x: anchorAbsolutePosition.x,
+                    y: anchorAbsolutePosition.y,
+                    width: 0,
+                    height: 0
+                };
+                itemPosition = ControllableLabel.alignedPosition(extend(itemOptions, {
+                    width: width,
+                    height: height
+                }), alignTo);
+                if (this.options.overflow === 'justify') {
+                    itemPosition = ControllableLabel.alignedPosition(ControllableLabel.justifiedOptions(chart, item, itemOptions, itemPosition), alignTo);
+                }
+            }
+            if (itemOptions.crop) {
+                itemPosRelativeX = itemPosition.x - chart.plotLeft;
+                itemPosRelativeY = itemPosition.y - chart.plotTop;
+                showItem =
+                    chart.isInsidePlot(itemPosRelativeX, itemPosRelativeY) &&
+                        chart.isInsidePlot(itemPosRelativeX + width, itemPosRelativeY + height);
+            }
+        }
+        return showItem ? itemPosition : null;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * A map object which allows to map options attributes to element attributes
+     *
+     * @type {Highcharts.Dictionary<string>}
+     */
+    ControllableLabel.attrsMap = {
+        backgroundColor: 'fill',
+        borderColor: 'stroke',
+        borderWidth: 'stroke-width',
+        zIndex: 'zIndex',
+        borderRadius: 'r',
+        padding: 'padding'
+    };
+    /**
+     * Shapes which do not have background - the object is used for proper
+     * setting of the contrast color.
+     *
+     * @type {Array<string>}
+     */
+    ControllableLabel.shapesWithoutBackground = ['connector'];
+    return ControllableLabel;
+}());
+export default ControllableLabel;
+/**
+ * General symbol definition for labels with connector
+ * @private
+ */
+symbols.connector = function (x, y, w, h, options) {
+    var anchorX = options && options.anchorX, anchorY = options && options.anchorY;
+    var path, yOffset, lateral = w / 2;
+    if (isNumber(anchorX) && isNumber(anchorY)) {
+        path = [['M', anchorX, anchorY]];
+        // Prefer 45 deg connectors
+        yOffset = y - anchorY;
+        if (yOffset < 0) {
+            yOffset = -h - yOffset;
+        }
+        if (yOffset < w) {
+            lateral = anchorX < x + (w / 2) ? yOffset : w - yOffset;
+        }
+        // Anchor below label
+        if (anchorY > y + h) {
+            path.push(['L', x + lateral, y + h]);
+            // Anchor above label
+        }
+        else if (anchorY < y) {
+            path.push(['L', x + lateral, y]);
+            // Anchor left of label
+        }
+        else if (anchorX < x) {
+            path.push(['L', x, y + h / 2]);
+            // Anchor right of label
+        }
+        else if (anchorX > x + w) {
+            path.push(['L', x + w, y + h / 2]);
+        }
+    }
+    return path || [];
+};

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Annotations/Controllables/ControllablePath.js

@@ -0,0 +1,181 @@
+/* *
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import ControllableMixin from '../Mixins/ControllableMixin.js';
+import H from '../../../Core/Globals.js';
+import MarkerMixin from '../Mixins/MarkerMixin.js';
+import U from '../../../Core/Utilities.js';
+var extend = U.extend;
+// See TRACKER_FILL in highcharts.src.js
+var TRACKER_FILL = 'rgba(192,192,192,' + (H.svg ? 0.0001 : 0.002) + ')';
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * A controllable path class.
+ *
+ * @requires modules/annotations
+ *
+ * @private
+ * @class
+ * @name Highcharts.AnnotationControllablePath
+ *
+ * @param {Highcharts.Annotation}
+ * Related annotation.
+ *
+ * @param {Highcharts.AnnotationsShapeOptions} options
+ * A path's options object.
+ *
+ * @param {number} index
+ * Index of the path.
+ */
+var ControllablePath = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function ControllablePath(annotation, options, index) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.addControlPoints = ControllableMixin.addControlPoints;
+        this.anchor = ControllableMixin.anchor;
+        this.attr = ControllableMixin.attr;
+        this.attrsFromOptions = ControllableMixin.attrsFromOptions;
+        this.destroy = ControllableMixin.destroy;
+        this.getPointsOptions = ControllableMixin.getPointsOptions;
+        this.init = ControllableMixin.init;
+        this.linkPoints = ControllableMixin.linkPoints;
+        this.point = ControllableMixin.point;
+        this.rotate = ControllableMixin.rotate;
+        this.scale = ControllableMixin.scale;
+        this.setControlPointsVisibility = (ControllableMixin.setControlPointsVisibility);
+        this.setMarkers = MarkerMixin.setItemMarkers;
+        this.transform = ControllableMixin.transform;
+        this.transformPoint = ControllableMixin.transformPoint;
+        this.translate = ControllableMixin.translate;
+        this.translatePoint = ControllableMixin.translatePoint;
+        this.translateShape = ControllableMixin.translateShape;
+        this.update = ControllableMixin.update;
+        /**
+         * @type 'path'
+         */
+        this.type = 'path';
+        this.init(annotation, options, index);
+        this.collection = 'shapes';
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Map the controllable path to 'd' path attribute.
+     *
+     * @return {Highcharts.SVGPathArray|null}
+     * A path's d attribute.
+     */
+    ControllablePath.prototype.toD = function () {
+        var dOption = this.options.d;
+        if (dOption) {
+            return typeof dOption === 'function' ?
+                dOption.call(this) :
+                dOption;
+        }
+        var points = this.points, len = points.length, showPath = len, point = points[0], position = showPath && this.anchor(point).absolutePosition, pointIndex = 0, command, d = [];
+        if (position) {
+            d.push(['M', position.x, position.y]);
+            while (++pointIndex < len && showPath) {
+                point = points[pointIndex];
+                command = point.command || 'L';
+                position = this.anchor(point).absolutePosition;
+                if (command === 'M') {
+                    d.push([command, position.x, position.y]);
+                }
+                else if (command === 'L') {
+                    d.push([command, position.x, position.y]);
+                }
+                else if (command === 'Z') {
+                    d.push([command]);
+                }
+                showPath = point.series.visible;
+            }
+        }
+        return showPath ?
+            this.chart.renderer.crispLine(d, this.graphic.strokeWidth()) :
+            null;
+    };
+    ControllablePath.prototype.shouldBeDrawn = function () {
+        return (ControllableMixin.shouldBeDrawn.call(this) ||
+            Boolean(this.options.d));
+    };
+    ControllablePath.prototype.render = function (parent) {
+        var options = this.options, attrs = this.attrsFromOptions(options);
+        this.graphic = this.annotation.chart.renderer
+            .path([['M', 0, 0]])
+            .attr(attrs)
+            .add(parent);
+        if (options.className) {
+            this.graphic.addClass(options.className);
+        }
+        this.tracker = this.annotation.chart.renderer
+            .path([['M', 0, 0]])
+            .addClass('highcharts-tracker-line')
+            .attr({
+            zIndex: 2
+        })
+            .add(parent);
+        if (!this.annotation.chart.styledMode) {
+            this.tracker.attr({
+                'stroke-linejoin': 'round',
+                stroke: TRACKER_FILL,
+                fill: TRACKER_FILL,
+                'stroke-width': this.graphic.strokeWidth() +
+                    options.snap * 2
+            });
+        }
+        ControllableMixin.render.call(this);
+        extend(this.graphic, {
+            markerStartSetter: MarkerMixin.markerStartSetter,
+            markerEndSetter: MarkerMixin.markerEndSetter
+        });
+        this.setMarkers(this);
+    };
+    ControllablePath.prototype.redraw = function (animation) {
+        var d = this.toD(), action = animation ? 'animate' : 'attr';
+        if (d) {
+            this.graphic[action]({ d: d });
+            this.tracker[action]({ d: d });
+        }
+        else {
+            this.graphic.attr({ d: 'M 0 ' + -9e9 });
+            this.tracker.attr({ d: 'M 0 ' + -9e9 });
+        }
+        this.graphic.placed = this.tracker.placed = Boolean(d);
+        ControllableMixin.redraw.call(this, animation);
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * A map object which allows to map options attributes to element attributes
+     *
+     * @name Highcharts.AnnotationControllablePath.attrsMap
+     * @type {Highcharts.Dictionary<string>}
+     */
+    ControllablePath.attrsMap = {
+        dashStyle: 'dashstyle',
+        strokeWidth: 'stroke-width',
+        stroke: 'stroke',
+        fill: 'fill',
+        zIndex: 'zIndex'
+    };
+    return ControllablePath;
+}());
+export default ControllablePath;

package/src/assets/plugins/highcharts/code/es-modules/Extensions/Annotations/Controllables/ControllableRect.js

@@ -0,0 +1,121 @@
+/* *
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+import ControllableMixin from '../Mixins/ControllableMixin.js';
+import ControllablePath from './ControllablePath.js';
+import U from '../../../Core/Utilities.js';
+var merge = U.merge;
+/**
+ * @typedef {Annotation.ControllablePath.AttrsMap}
+ *          Annotation.ControllableRect.AttrsMap
+ * @property {string} width=width
+ * @property {string} height=height
+ */
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * A controllable rect class.
+ *
+ * @requires modules/annotations
+ *
+ * @private
+ * @class
+ * @name Highcharts.AnnotationControllableRect
+ *
+ * @param {Highcharts.Annotation} annotation
+ * An annotation instance.
+ *
+ * @param {Highcharts.AnnotationsShapeOptions} options
+ * A rect's options.
+ *
+ * @param {number} index
+ * Index of the rectangle
+ */
+var ControllableRect = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function ControllableRect(annotation, options, index) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.addControlPoints = ControllableMixin.addControlPoints;
+        this.anchor = ControllableMixin.anchor;
+        this.attr = ControllableMixin.attr;
+        this.attrsFromOptions = ControllableMixin.attrsFromOptions;
+        this.destroy = ControllableMixin.destroy;
+        this.getPointsOptions = ControllableMixin.getPointsOptions;
+        this.init = ControllableMixin.init;
+        this.linkPoints = ControllableMixin.linkPoints;
+        this.point = ControllableMixin.point;
+        this.rotate = ControllableMixin.rotate;
+        this.scale = ControllableMixin.scale;
+        this.setControlPointsVisibility = (ControllableMixin.setControlPointsVisibility);
+        this.shouldBeDrawn = ControllableMixin.shouldBeDrawn;
+        this.transform = ControllableMixin.transform;
+        this.transformPoint = ControllableMixin.transformPoint;
+        this.translatePoint = ControllableMixin.translatePoint;
+        this.translateShape = ControllableMixin.translateShape;
+        this.update = ControllableMixin.update;
+        /**
+         * @type 'rect'
+         */
+        this.type = 'rect';
+        this.translate = ControllableMixin.translateShape;
+        this.init(annotation, options, index);
+        this.collection = 'shapes';
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    ControllableRect.prototype.render = function (parent) {
+        var attrs = this.attrsFromOptions(this.options);
+        this.graphic = this.annotation.chart.renderer
+            .rect(0, -9e9, 0, 0)
+            .attr(attrs)
+            .add(parent);
+        ControllableMixin.render.call(this);
+    };
+    ControllableRect.prototype.redraw = function (animation) {
+        var position = this.anchor(this.points[0]).absolutePosition;
+        if (position) {
+            this.graphic[animation ? 'animate' : 'attr']({
+                x: position.x,
+                y: position.y,
+                width: this.options.width,
+                height: this.options.height
+            });
+        }
+        else {
+            this.attr({
+                x: 0,
+                y: -9e9
+            });
+        }
+        this.graphic.placed = Boolean(position);
+        ControllableMixin.redraw.call(this, animation);
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    /**
+     * A map object which allows to map options attributes to element attributes
+     *
+     * @type {Annotation.ControllableRect.AttrsMap}
+     */
+    ControllableRect.attrsMap = merge(ControllablePath.attrsMap, {
+        width: 'width',
+        height: 'height'
+    });
+    return ControllableRect;
+}());
+export default ControllableRect;