ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/es-modules/Accessibility/Components/ZoomComponent.js

@@ -0,0 +1,375 @@
+/* *
+ *
+ *  (c) 2009-2021 Øystein Moseng
+ *
+ *  Accessibility component for chart zoom.
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import AccessibilityComponent from '../AccessibilityComponent.js';
+import ChartUtilities from '../Utils/ChartUtilities.js';
+var unhideChartElementFromAT = ChartUtilities.unhideChartElementFromAT;
+import H from '../../Core/Globals.js';
+var noop = H.noop;
+import KeyboardNavigationHandler from '../KeyboardNavigationHandler.js';
+import U from '../../Core/Utilities.js';
+var attr = U.attr, extend = U.extend, pick = U.pick;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/* eslint-disable valid-jsdoc */
+/**
+ * @private
+ */
+function chartHasMapZoom(chart) {
+    return !!(chart.mapZoom &&
+        chart.mapNavButtons &&
+        chart.mapNavButtons.length);
+}
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * The ZoomComponent class
+ *
+ * @private
+ * @class
+ * @name Highcharts.ZoomComponent
+ */
+var ZoomComponent = /** @class */ (function (_super) {
+    __extends(ZoomComponent, _super);
+    function ZoomComponent() {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.focusedMapNavButtonIx = -1;
+        return _this;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Initialize the component
+     */
+    ZoomComponent.prototype.init = function () {
+        var component = this, chart = this.chart;
+        this.proxyProvider.addGroup('zoom', 'div');
+        [
+            'afterShowResetZoom', 'afterDrilldown', 'drillupall'
+        ].forEach(function (eventType) {
+            component.addEvent(chart, eventType, function () {
+                component.updateProxyOverlays();
+            });
+        });
+    };
+    /**
+     * Called when chart is updated
+     */
+    ZoomComponent.prototype.onChartUpdate = function () {
+        var chart = this.chart, component = this;
+        // Make map zoom buttons accessible
+        if (chart.mapNavButtons) {
+            chart.mapNavButtons.forEach(function (button, i) {
+                unhideChartElementFromAT(chart, button.element);
+                component.setMapNavButtonAttrs(button.element, 'accessibility.zoom.mapZoom' + (i ? 'Out' : 'In'));
+            });
+        }
+    };
+    /**
+     * @private
+     * @param {Highcharts.HTMLDOMElement|Highcharts.SVGDOMElement} button
+     * @param {string} labelFormatKey
+     */
+    ZoomComponent.prototype.setMapNavButtonAttrs = function (button, labelFormatKey) {
+        var chart = this.chart, label = chart.langFormat(labelFormatKey, { chart: chart });
+        attr(button, {
+            tabindex: -1,
+            role: 'button',
+            'aria-label': label
+        });
+    };
+    /**
+     * Update the proxy overlays on every new render to ensure positions are
+     * correct.
+     */
+    ZoomComponent.prototype.onChartRender = function () {
+        this.updateProxyOverlays();
+    };
+    /**
+     * Update proxy overlays, recreating the buttons.
+     */
+    ZoomComponent.prototype.updateProxyOverlays = function () {
+        var chart = this.chart;
+        // Always start with a clean slate
+        this.proxyProvider.clearGroup('zoom');
+        if (chart.resetZoomButton) {
+            this.createZoomProxyButton(chart.resetZoomButton, 'resetZoomProxyButton', chart.langFormat('accessibility.zoom.resetZoomButton', { chart: chart }));
+        }
+        if (chart.drillUpButton) {
+            this.createZoomProxyButton(chart.drillUpButton, 'drillUpProxyButton', chart.langFormat('accessibility.drillUpButton', {
+                chart: chart,
+                buttonText: chart.getDrilldownBackText()
+            }));
+        }
+    };
+    /**
+     * @private
+     * @param {Highcharts.SVGElement} buttonEl
+     * @param {string} buttonProp
+     * @param {string} label
+     */
+    ZoomComponent.prototype.createZoomProxyButton = function (buttonEl, buttonProp, label) {
+        this[buttonProp] = this.proxyProvider.addProxyElement('zoom', {
+            click: buttonEl
+        }, {
+            'aria-label': label,
+            tabindex: -1
+        });
+    };
+    /**
+     * Get keyboard navigation handler for map zoom.
+     * @private
+     * @return {Highcharts.KeyboardNavigationHandler} The module object
+     */
+    ZoomComponent.prototype.getMapZoomNavigation = function () {
+        var keys = this.keyCodes, chart = this.chart, component = this;
+        return new KeyboardNavigationHandler(chart, {
+            keyCodeMap: [
+                [
+                    [keys.up, keys.down, keys.left, keys.right],
+                    function (keyCode) {
+                        return component.onMapKbdArrow(this, keyCode);
+                    }
+                ],
+                [
+                    [keys.tab],
+                    function (_keyCode, e) {
+                        return component.onMapKbdTab(this, e);
+                    }
+                ],
+                [
+                    [keys.space, keys.enter],
+                    function () {
+                        return component.onMapKbdClick(this);
+                    }
+                ]
+            ],
+            validate: function () {
+                return chartHasMapZoom(chart);
+            },
+            init: function (direction) {
+                return component.onMapNavInit(direction);
+            }
+        });
+    };
+    /**
+     * @private
+     * @param {Highcharts.KeyboardNavigationHandler} keyboardNavigationHandler
+     * @param {number} keyCode
+     * @return {number} Response code
+     */
+    ZoomComponent.prototype.onMapKbdArrow = function (keyboardNavigationHandler, keyCode) {
+        var keys = this.keyCodes, panAxis = (keyCode === keys.up || keyCode === keys.down) ?
+            'yAxis' : 'xAxis', stepDirection = (keyCode === keys.left || keyCode === keys.up) ?
+            -1 : 1;
+        this.chart[panAxis][0].panStep(stepDirection);
+        return keyboardNavigationHandler.response.success;
+    };
+    /**
+     * @private
+     * @param {Highcharts.KeyboardNavigationHandler} keyboardNavigationHandler
+     * @param {global.KeyboardEvent} event
+     * @return {number} Response code
+     */
+    ZoomComponent.prototype.onMapKbdTab = function (keyboardNavigationHandler, event) {
+        var chart = this.chart;
+        var response = keyboardNavigationHandler.response;
+        var isBackwards = event.shiftKey;
+        var isMoveOutOfRange = isBackwards && !this.focusedMapNavButtonIx ||
+            !isBackwards && this.focusedMapNavButtonIx;
+        // Deselect old
+        chart.mapNavButtons[this.focusedMapNavButtonIx].setState(0);
+        if (isMoveOutOfRange) {
+            chart.mapZoom(); // Reset zoom
+            return response[isBackwards ? 'prev' : 'next'];
+        }
+        // Select other button
+        this.focusedMapNavButtonIx += isBackwards ? -1 : 1;
+        var button = chart.mapNavButtons[this.focusedMapNavButtonIx];
+        chart.setFocusToElement(button.box, button.element);
+        button.setState(2);
+        return response.success;
+    };
+    /**
+     * @private
+     * @param {Highcharts.KeyboardNavigationHandler} keyboardNavigationHandler
+     * @return {number} Response code
+     */
+    ZoomComponent.prototype.onMapKbdClick = function (keyboardNavigationHandler) {
+        var el = this.chart.mapNavButtons[this.focusedMapNavButtonIx].element;
+        this.fakeClickEvent(el);
+        return keyboardNavigationHandler.response.success;
+    };
+    /**
+     * @private
+     * @param {number} direction
+     */
+    ZoomComponent.prototype.onMapNavInit = function (direction) {
+        var chart = this.chart, zoomIn = chart.mapNavButtons[0], zoomOut = chart.mapNavButtons[1], initialButton = direction > 0 ? zoomIn : zoomOut;
+        chart.setFocusToElement(initialButton.box, initialButton.element);
+        initialButton.setState(2);
+        this.focusedMapNavButtonIx = direction > 0 ? 0 : 1;
+    };
+    /**
+     * Get keyboard navigation handler for a simple chart button. Provide the
+     * button reference for the chart, and a function to call on click.
+     *
+     * @private
+     * @param {string} buttonProp The property on chart referencing the button.
+     * @return {Highcharts.KeyboardNavigationHandler} The module object
+     */
+    ZoomComponent.prototype.simpleButtonNavigation = function (buttonProp, proxyProp, onClick) {
+        var keys = this.keyCodes, component = this, chart = this.chart;
+        return new KeyboardNavigationHandler(chart, {
+            keyCodeMap: [
+                [
+                    [keys.tab, keys.up, keys.down, keys.left, keys.right],
+                    function (keyCode, e) {
+                        var isBackwards = (keyCode === keys.tab && e.shiftKey ||
+                            keyCode === keys.left ||
+                            keyCode === keys.up);
+                        // Arrow/tab => just move
+                        return this.response[isBackwards ? 'prev' : 'next'];
+                    }
+                ],
+                [
+                    [keys.space, keys.enter],
+                    function () {
+                        var res = onClick(this, chart);
+                        return pick(res, this.response.success);
+                    }
+                ]
+            ],
+            validate: function () {
+                var hasButton = (chart[buttonProp] &&
+                    chart[buttonProp].box &&
+                    component[proxyProp].buttonElement);
+                return hasButton;
+            },
+            init: function () {
+                chart.setFocusToElement(chart[buttonProp].box, component[proxyProp].buttonElement);
+            }
+        });
+    };
+    /**
+     * Get keyboard navigation handlers for this component.
+     * @return {Array<Highcharts.KeyboardNavigationHandler>}
+     *         List of module objects
+     */
+    ZoomComponent.prototype.getKeyboardNavigation = function () {
+        return [
+            this.simpleButtonNavigation('resetZoomButton', 'resetZoomProxyButton', function (_handler, chart) {
+                chart.zoomOut();
+            }),
+            this.simpleButtonNavigation('drillUpButton', 'drillUpProxyButton', function (handler, chart) {
+                chart.drillUp();
+                return handler.response.prev;
+            }),
+            this.getMapZoomNavigation()
+        ];
+    };
+    return ZoomComponent;
+}(AccessibilityComponent));
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+(function (ZoomComponent) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    ZoomComponent.composedClasses = [];
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * @private
+     */
+    function compose(AxisClass) {
+        if (ZoomComponent.composedClasses.indexOf(AxisClass) === -1) {
+            ZoomComponent.composedClasses.push(AxisClass);
+            var axisProto = AxisClass.prototype;
+            axisProto.panStep = axisPanStep;
+        }
+    }
+    ZoomComponent.compose = compose;
+    /**
+     * Pan along axis in a direction (1 or -1), optionally with a defined
+     * granularity (number of steps it takes to walk across current view)
+     *
+     * @private
+     * @function Highcharts.Axis#panStep
+     *
+     * @param {number} direction
+     * @param {number} [granularity]
+     */
+    function axisPanStep(direction, granularity) {
+        var gran = granularity || 3;
+        var extremes = this.getExtremes();
+        var step = (extremes.max - extremes.min) / gran * direction;
+        var newMax = extremes.max + step;
+        var newMin = extremes.min + step;
+        var size = newMax - newMin;
+        if (direction < 0 && newMin < extremes.dataMin) {
+            newMin = extremes.dataMin;
+            newMax = newMin + size;
+        }
+        else if (direction > 0 && newMax > extremes.dataMax) {
+            newMax = extremes.dataMax;
+            newMin = newMax - size;
+        }
+        this.setExtremes(newMin, newMax);
+    }
+})(ZoomComponent || (ZoomComponent = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default ZoomComponent;

package/src/assets/plugins/highcharts/code/es-modules/Accessibility/FocusBorder.js

@@ -0,0 +1,302 @@
+/* *
+ *
+ *  (c) 2009-2021 Øystein Moseng
+ *
+ *  Extend SVG and Chart classes with focus border capabilities.
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import SVGLabel from '../Core/Renderer/SVG/SVGLabel.js';
+import U from '../Core/Utilities.js';
+var addEvent = U.addEvent, pick = U.pick;
+/* *
+ *
+ *  Composition
+ *
+ * */
+var FocusBorderComposition;
+(function (FocusBorderComposition) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    var composedClasses = [];
+    // Attributes that trigger a focus border update
+    var svgElementBorderUpdateTriggers = [
+        'x', 'y', 'transform', 'width', 'height', 'r', 'd', 'stroke-width'
+    ];
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
+    /**
+     * @private
+     */
+    function compose(ChartClass, SVGElementClass) {
+        if (composedClasses.indexOf(ChartClass) === -1) {
+            composedClasses.push(ChartClass);
+            var chartProto = ChartClass.prototype;
+            chartProto.renderFocusBorder = chartRenderFocusBorder;
+            chartProto.setFocusToElement = chartSetFocusToElement;
+        }
+        if (composedClasses.indexOf(SVGElementClass) === -1) {
+            composedClasses.push(SVGElementClass);
+            var svgElementProto = SVGElementClass.prototype;
+            svgElementProto.addFocusBorder = svgElementAddFocusBorder;
+            svgElementProto.removeFocusBorder = svgElementRemoveFocusBorder;
+        }
+    }
+    FocusBorderComposition.compose = compose;
+    /**
+     * Redraws the focus border on the currently focused element.
+     *
+     * @private
+     * @function Highcharts.Chart#renderFocusBorder
+     */
+    function chartRenderFocusBorder() {
+        var focusElement = this.focusElement, focusBorderOptions = this.options.accessibility.keyboardNavigation.focusBorder;
+        if (focusElement) {
+            focusElement.removeFocusBorder();
+            if (focusBorderOptions.enabled) {
+                focusElement.addFocusBorder(focusBorderOptions.margin, {
+                    stroke: focusBorderOptions.style.color,
+                    strokeWidth: focusBorderOptions.style.lineWidth,
+                    r: focusBorderOptions.style.borderRadius
+                });
+            }
+        }
+    }
+    /**
+     * Set chart's focus to an SVGElement. Calls focus() on it, and draws the
+     * focus border. This is used by multiple components.
+     *
+     * @private
+     * @function Highcharts.Chart#setFocusToElement
+     *
+     * @param {Highcharts.SVGElement} svgElement
+     * Element to draw the border around.
+     *
+     * @param {SVGDOMElement|HTMLDOMElement} [focusElement]
+     * If supplied, it draws the border around svgElement and sets the focus to
+     * focusElement.
+     */
+    function chartSetFocusToElement(svgElement, focusElement) {
+        var focusBorderOptions = this.options.accessibility.keyboardNavigation.focusBorder, browserFocusElement = focusElement || svgElement.element;
+        // Set browser focus if possible
+        if (browserFocusElement &&
+            browserFocusElement.focus) {
+            // If there is no focusin-listener, add one to work around Edge
+            // where Narrator is not reading out points despite calling focus().
+            if (!(browserFocusElement.hcEvents &&
+                browserFocusElement.hcEvents.focusin)) {
+                addEvent(browserFocusElement, 'focusin', function () { });
+            }
+            browserFocusElement.focus();
+            // Hide default focus ring
+            if (focusBorderOptions.hideBrowserFocusOutline) {
+                browserFocusElement.style.outline = 'none';
+            }
+        }
+        if (this.focusElement) {
+            this.focusElement.removeFocusBorder();
+        }
+        this.focusElement = svgElement;
+        this.renderFocusBorder();
+    }
+    /**
+     * Add hook to destroy focus border if SVG element is destroyed, unless
+     * hook already exists.
+     * @private
+     * @param el Element to add destroy hook to
+     */
+    function svgElementAddDestroyFocusBorderHook(el) {
+        if (el.focusBorderDestroyHook) {
+            return;
+        }
+        var origDestroy = el.destroy;
+        el.destroy = function () {
+            if (el.focusBorder && el.focusBorder.destroy) {
+                el.focusBorder.destroy();
+            }
+            return origDestroy.apply(el, arguments);
+        };
+        el.focusBorderDestroyHook = origDestroy;
+    }
+    /**
+     * Add focus border functionality to SVGElements. Draws a new rect on top of
+     * element around its bounding box. This is used by multiple components.
+     *
+     * @private
+     * @function Highcharts.SVGElement#addFocusBorder
+     *
+     * @param {number} margin
+     *
+     * @param {SVGAttributes} attribs
+     */
+    function svgElementAddFocusBorder(margin, attribs) {
+        // Allow updating by just adding new border
+        if (this.focusBorder) {
+            this.removeFocusBorder();
+        }
+        // Add the border rect
+        var bb = this.getBBox(), pad = pick(margin, 3);
+        bb.x += this.translateX ? this.translateX : 0;
+        bb.y += this.translateY ? this.translateY : 0;
+        var borderPosX = bb.x - pad, borderPosY = bb.y - pad, borderWidth = bb.width + 2 * pad, borderHeight = bb.height + 2 * pad;
+        // For text elements, apply x and y offset, #11397.
+        /**
+         * @private
+         */
+        function getTextAnchorCorrection(text) {
+            var posXCorrection = 0, posYCorrection = 0;
+            if (text.attr('text-anchor') === 'middle') {
+                posXCorrection = posYCorrection = 0.5;
+            }
+            else if (!text.rotation) {
+                posYCorrection = 0.75;
+            }
+            else {
+                posXCorrection = 0.25;
+            }
+            return {
+                x: posXCorrection,
+                y: posYCorrection
+            };
+        }
+        var isLabel = this instanceof SVGLabel;
+        if (this.element.nodeName === 'text' || isLabel) {
+            var isRotated = !!this.rotation;
+            var correction = !isLabel ? getTextAnchorCorrection(this) :
+                {
+                    x: isRotated ? 1 : 0,
+                    y: 0
+                };
+            var attrX = +this.attr('x');
+            var attrY = +this.attr('y');
+            if (!isNaN(attrX)) {
+                borderPosX = attrX - (bb.width * correction.x) - pad;
+            }
+            if (!isNaN(attrY)) {
+                borderPosY = attrY - (bb.height * correction.y) - pad;
+            }
+            if (isLabel && isRotated) {
+                var temp = borderWidth;
+                borderWidth = borderHeight;
+                borderHeight = temp;
+                if (!isNaN(attrX)) {
+                    borderPosX = attrX - (bb.height * correction.x) - pad;
+                }
+                if (!isNaN(attrY)) {
+                    borderPosY = attrY - (bb.width * correction.y) - pad;
+                }
+            }
+        }
+        this.focusBorder = this.renderer.rect(borderPosX, borderPosY, borderWidth, borderHeight, parseInt((attribs && attribs.r || 0).toString(), 10))
+            .addClass('highcharts-focus-border')
+            .attr({
+            zIndex: 99
+        })
+            .add(this.parentGroup);
+        if (!this.renderer.styledMode) {
+            this.focusBorder.attr({
+                stroke: attribs && attribs.stroke,
+                'stroke-width': attribs && attribs.strokeWidth
+            });
+        }
+        avgElementAddUpdateFocusBorderHooks(this, margin, attribs);
+        svgElementAddDestroyFocusBorderHook(this);
+    }
+    /**
+     * Add hooks to update the focus border of an element when the element
+     * size/position is updated, unless already added.
+     * @private
+     * @param el Element to add update hooks to
+     * @param updateParams Parameters to pass through to addFocusBorder when updating.
+     */
+    function avgElementAddUpdateFocusBorderHooks(el) {
+        var updateParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            updateParams[_i - 1] = arguments[_i];
+        }
+        if (el.focusBorderUpdateHooks) {
+            return;
+        }
+        el.focusBorderUpdateHooks = {};
+        svgElementBorderUpdateTriggers.forEach(function (trigger) {
+            var setterKey = trigger + 'Setter';
+            var origSetter = el[setterKey] || el._defaultSetter;
+            el.focusBorderUpdateHooks[setterKey] = origSetter;
+            el[setterKey] = function () {
+                var ret = origSetter.apply(el, arguments);
+                el.addFocusBorder.apply(el, updateParams);
+                return ret;
+            };
+        });
+    }
+    /**
+     * Remove hook from SVG element added by addDestroyFocusBorderHook, if
+     * existing.
+     * @private
+     * @param el Element to remove destroy hook from
+     */
+    function svgElementRemoveDestroyFocusBorderHook(el) {
+        if (!el.focusBorderDestroyHook) {
+            return;
+        }
+        el.destroy = el.focusBorderDestroyHook;
+        delete el.focusBorderDestroyHook;
+    }
+    /**
+     * Add focus border functionality to SVGElements. Draws a new rect on top of
+     * element around its bounding box. This is used by multiple components.
+     * @private
+     * @function Highcharts.SVGElement#removeFocusBorder
+     */
+    function svgElementRemoveFocusBorder() {
+        svgElementRemoveUpdateFocusBorderHooks(this);
+        svgElementRemoveDestroyFocusBorderHook(this);
+        if (this.focusBorder) {
+            this.focusBorder.destroy();
+            delete this.focusBorder;
+        }
+    }
+    /**
+     * Remove hooks from SVG element added by addUpdateFocusBorderHooks, if
+     * existing.
+     * @private
+     * @param el Element to remove update hooks from
+     */
+    function svgElementRemoveUpdateFocusBorderHooks(el) {
+        if (!el.focusBorderUpdateHooks) {
+            return;
+        }
+        Object.keys(el.focusBorderUpdateHooks).forEach(function (setterKey) {
+            var origSetter = el.focusBorderUpdateHooks[setterKey];
+            if (origSetter === el._defaultSetter) {
+                delete el[setterKey];
+            }
+            else {
+                el[setterKey] = origSetter;
+            }
+        });
+        delete el.focusBorderUpdateHooks;
+    }
+})(FocusBorderComposition || (FocusBorderComposition = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default FocusBorderComposition;