ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/es-modules/Core/Renderer/HTML/HTMLElement.js

@@ -0,0 +1,261 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  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 H from '../../Globals.js';
+var isFirefox = H.isFirefox, isMS = H.isMS, isWebKit = H.isWebKit, win = H.win;
+import SVGElement from '../SVG/SVGElement.js';
+import U from '../../Utilities.js';
+var css = U.css, defined = U.defined, extend = U.extend, pick = U.pick, pInt = U.pInt;
+/* *
+ *
+ *  Class
+ *
+ * */
+/* eslint-disable valid-jsdoc */
+var HTMLElement = /** @class */ (function (_super) {
+    __extends(HTMLElement, _super);
+    function HTMLElement() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * Modifies SVGElement to support HTML elements.
+     * @private
+     */
+    HTMLElement.compose = function (SVGElementClass) {
+        if (HTMLElement.composedClasses.indexOf(SVGElementClass) === -1) {
+            HTMLElement.composedClasses.push(SVGElementClass);
+            var htmlElementProto = HTMLElement.prototype, svgElementProto = SVGElementClass.prototype;
+            svgElementProto.getSpanCorrection = htmlElementProto
+                .getSpanCorrection;
+            svgElementProto.htmlCss = htmlElementProto.htmlCss;
+            svgElementProto.htmlGetBBox = htmlElementProto.htmlGetBBox;
+            svgElementProto.htmlUpdateTransform = htmlElementProto
+                .htmlUpdateTransform;
+            svgElementProto.setSpanRotation = htmlElementProto.setSpanRotation;
+        }
+        return SVGElementClass;
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Get the correction in X and Y positioning as the element is rotated.
+     * @private
+     */
+    HTMLElement.prototype.getSpanCorrection = function (width, baseline, alignCorrection) {
+        this.xCorr = -width * alignCorrection;
+        this.yCorr = -baseline;
+    };
+    /**
+     * Apply CSS to HTML elements. This is used in text within SVG rendering and
+     * by the VML renderer
+     * @private
+     */
+    HTMLElement.prototype.htmlCss = function (styles) {
+        var wrapper = this, element = wrapper.element, 
+        // When setting or unsetting the width style, we need to update
+        // transform (#8809)
+        isSettingWidth = (element.tagName === 'SPAN' &&
+            styles &&
+            'width' in styles), textWidth = pick(isSettingWidth && styles.width, void 0);
+        var doTransform;
+        if (isSettingWidth) {
+            delete styles.width;
+            wrapper.textWidth = textWidth;
+            doTransform = true;
+        }
+        if (styles && styles.textOverflow === 'ellipsis') {
+            styles.whiteSpace = 'nowrap';
+            styles.overflow = 'hidden';
+        }
+        wrapper.styles = extend(wrapper.styles, styles);
+        css(wrapper.element, styles);
+        // Now that all styles are applied, to the transform
+        if (doTransform) {
+            wrapper.htmlUpdateTransform();
+        }
+        return wrapper;
+    };
+    /**
+     * VML and useHTML method for calculating the bounding box based on offsets.
+     */
+    HTMLElement.prototype.htmlGetBBox = function () {
+        var wrapper = this, element = wrapper.element;
+        return {
+            x: element.offsetLeft,
+            y: element.offsetTop,
+            width: element.offsetWidth,
+            height: element.offsetHeight
+        };
+    };
+    /**
+     * VML override private method to update elements based on internal
+     * properties based on SVG transform.
+     * @private
+     */
+    HTMLElement.prototype.htmlUpdateTransform = function () {
+        // aligning non added elements is expensive
+        if (!this.added) {
+            this.alignOnAdd = true;
+            return;
+        }
+        var wrapper = this, renderer = wrapper.renderer, elem = wrapper.element, translateX = wrapper.translateX || 0, translateY = wrapper.translateY || 0, x = wrapper.x || 0, y = wrapper.y || 0, align = wrapper.textAlign || 'left', alignCorrection = {
+            left: 0, center: 0.5, right: 1
+        }[align], styles = wrapper.styles, whiteSpace = styles && styles.whiteSpace;
+        /** @private */
+        function getTextPxLength() {
+            if (wrapper.textPxLength) {
+                return wrapper.textPxLength;
+            }
+            // Reset multiline/ellipsis in order to read width (#4928,
+            // #5417)
+            css(elem, {
+                width: '',
+                whiteSpace: whiteSpace || 'nowrap'
+            });
+            return elem.offsetWidth;
+        }
+        // apply translate
+        css(elem, {
+            marginLeft: translateX,
+            marginTop: translateY
+        });
+        if (!renderer.styledMode && wrapper.shadows) { // used in labels/tooltip
+            wrapper.shadows.forEach(function (shadow) {
+                css(shadow, {
+                    marginLeft: translateX + 1,
+                    marginTop: translateY + 1
+                });
+            });
+        }
+        // apply inversion
+        if (wrapper.inverted) { // wrapper is a group
+            [].forEach.call(elem.childNodes, function (child) {
+                renderer.invertChild(child, elem);
+            });
+        }
+        if (elem.tagName === 'SPAN') {
+            var rotation = wrapper.rotation, textWidth = wrapper.textWidth && pInt(wrapper.textWidth), currentTextTransform = [
+                rotation,
+                align,
+                elem.innerHTML,
+                wrapper.textWidth,
+                wrapper.textAlign
+            ].join(',');
+            var baseline = void 0, hasBoxWidthChanged = false;
+            // Update textWidth. Use the memoized textPxLength if possible, to
+            // avoid the getTextPxLength function using elem.offsetWidth.
+            // Calling offsetWidth affects rendering time as it forces layout
+            // (#7656).
+            if (textWidth !== wrapper.oldTextWidth) { // #983, #1254
+                var textPxLength = getTextPxLength();
+                if (((textWidth > wrapper.oldTextWidth) ||
+                    textPxLength > textWidth) && (
+                // Only set the width if the text is able to word-wrap,
+                // or text-overflow is ellipsis (#9537)
+                /[ \-]/.test(elem.textContent || elem.innerText) ||
+                    elem.style.textOverflow === 'ellipsis')) {
+                    css(elem, {
+                        width: (textPxLength > textWidth) || rotation ?
+                            textWidth + 'px' :
+                            'auto',
+                        display: 'block',
+                        whiteSpace: whiteSpace || 'normal' // #3331
+                    });
+                    wrapper.oldTextWidth = textWidth;
+                    hasBoxWidthChanged = true; // #8159
+                }
+            }
+            wrapper.hasBoxWidthChanged = hasBoxWidthChanged; // #8159
+            // Do the calculations and DOM access only if properties changed
+            if (currentTextTransform !== wrapper.cTT) {
+                baseline = renderer.fontMetrics(elem.style.fontSize, elem).b;
+                // Renderer specific handling of span rotation, but only if we
+                // have something to update.
+                if (defined(rotation) &&
+                    ((rotation !== (wrapper.oldRotation || 0)) ||
+                        (align !== wrapper.oldAlign))) {
+                    wrapper.setSpanRotation(rotation, alignCorrection, baseline);
+                }
+                wrapper.getSpanCorrection(
+                // Avoid elem.offsetWidth if we can, it affects rendering
+                // time heavily (#7656)
+                ((!defined(rotation) && wrapper.textPxLength) || // #7920
+                    elem.offsetWidth), baseline, alignCorrection, rotation, align);
+            }
+            // apply position with correction
+            css(elem, {
+                left: (x + (wrapper.xCorr || 0)) + 'px',
+                top: (y + (wrapper.yCorr || 0)) + 'px'
+            });
+            // record current text transform
+            wrapper.cTT = currentTextTransform;
+            wrapper.oldRotation = rotation;
+            wrapper.oldAlign = align;
+        }
+    };
+    /**
+     * Set the rotation of an individual HTML span.
+     * @private
+     */
+    HTMLElement.prototype.setSpanRotation = function (rotation, alignCorrection, baseline) {
+        var getTransformKey = function () { return (isMS &&
+            !/Edge/.test(win.navigator.userAgent) ?
+            '-ms-transform' :
+            isWebKit ?
+                '-webkit-transform' :
+                isFirefox ?
+                    'MozTransform' :
+                    win.opera ?
+                        '-o-transform' :
+                        void 0); };
+        var rotationStyle = {}, cssTransformKey = getTransformKey();
+        if (cssTransformKey) {
+            rotationStyle[cssTransformKey] = rotationStyle.transform =
+                'rotate(' + rotation + 'deg)';
+            rotationStyle[cssTransformKey + (isFirefox ? 'Origin' : '-origin')] = rotationStyle.transformOrigin =
+                (alignCorrection * 100) + '% ' + baseline + 'px';
+            css(this.element, rotationStyle);
+        }
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    HTMLElement.composedClasses = [];
+    return HTMLElement;
+}(SVGElement));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default HTMLElement;

package/src/assets/plugins/highcharts/code/es-modules/Core/Renderer/HTML/HTMLRenderer.js

@@ -0,0 +1,272 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  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 AST from './AST.js';
+import SVGElement from '../SVG/SVGElement.js';
+import SVGRenderer from '../SVG/SVGRenderer.js';
+import U from '../../Utilities.js';
+var attr = U.attr, createElement = U.createElement, extend = U.extend, pick = U.pick;
+/* *
+ *
+ *  Class
+ *
+ * */
+/* eslint-disable valid-jsdoc */
+// Extend SvgRenderer for useHTML option.
+var HTMLRenderer = /** @class */ (function (_super) {
+    __extends(HTMLRenderer, _super);
+    function HTMLRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /** @private */
+    HTMLRenderer.compose = function (SVGRendererClass) {
+        if (HTMLRenderer.composedClasses.indexOf(SVGRendererClass) === -1) {
+            HTMLRenderer.composedClasses.push(SVGRendererClass);
+            var htmlRendererProto = HTMLRenderer.prototype, svgRendererProto = SVGRendererClass.prototype;
+            svgRendererProto.html = htmlRendererProto.html;
+        }
+        return SVGRendererClass;
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Create HTML text node. This is used by the VML renderer as well as the
+     * SVG renderer through the useHTML option.
+     *
+     * @private
+     * @function Highcharts.SVGRenderer#html
+     *
+     * @param {string} str
+     * The text of (subset) HTML to draw.
+     *
+     * @param {number} x
+     * The x position of the text's lower left corner.
+     *
+     * @param {number} y
+     * The y position of the text's lower left corner.
+     *
+     * @return {Highcharts.HTMLDOMElement}
+     * HTML element.
+     */
+    HTMLRenderer.prototype.html = function (str, x, y) {
+        var wrapper = this.createElement('span'), element = wrapper.element, renderer = wrapper.renderer, isSVG = renderer.isSVG, addSetters = function (gWrapper, style) {
+            // These properties are set as attributes on the SVG group, and
+            // as identical CSS properties on the div. (#3542)
+            ['opacity', 'visibility'].forEach(function (prop) {
+                gWrapper[prop + 'Setter'] = function (value, key, elem) {
+                    var styleObject = gWrapper.div ?
+                        gWrapper.div.style :
+                        style;
+                    SVGElement.prototype[prop + 'Setter']
+                        .call(this, value, key, elem);
+                    if (styleObject) {
+                        styleObject[key] = value;
+                    }
+                };
+            });
+            gWrapper.addedSetters = true;
+        };
+        // Text setter
+        wrapper.textSetter = function (value) {
+            if (value !== this.textStr) {
+                delete this.bBox;
+                delete this.oldTextWidth;
+                AST.setElementHTML(this.element, pick(value, ''));
+                this.textStr = value;
+                wrapper.doTransform = true;
+            }
+        };
+        // Add setters for the element itself (#4938)
+        if (isSVG) { // #4938, only for HTML within SVG
+            addSetters(wrapper, wrapper.element.style);
+        }
+        // Various setters which rely on update transform
+        wrapper.xSetter =
+            wrapper.ySetter =
+                wrapper.alignSetter =
+                    wrapper.rotationSetter =
+                        function (value, key) {
+                            if (key === 'align') {
+                                // Do not overwrite the SVGElement.align method. Same as VML.
+                                wrapper.alignValue = wrapper.textAlign = value;
+                            }
+                            else {
+                                wrapper[key] = value;
+                            }
+                            wrapper.doTransform = true;
+                        };
+        // Runs at the end of .attr()
+        wrapper.afterSetters = function () {
+            // Update transform. Do this outside the loop to prevent redundant
+            // updating for batch setting of attributes.
+            if (this.doTransform) {
+                this.htmlUpdateTransform();
+                this.doTransform = false;
+            }
+        };
+        // Set the default attributes
+        wrapper
+            .attr({
+            text: str,
+            x: Math.round(x),
+            y: Math.round(y)
+        })
+            .css({
+            position: 'absolute'
+        });
+        if (!renderer.styledMode) {
+            wrapper.css({
+                fontFamily: this.style.fontFamily,
+                fontSize: this.style.fontSize
+            });
+        }
+        // Keep the whiteSpace style outside the wrapper.styles collection
+        element.style.whiteSpace = 'nowrap';
+        // Use the HTML specific .css method
+        wrapper.css = wrapper.htmlCss;
+        // This is specific for HTML within SVG
+        if (isSVG) {
+            wrapper.add = function (svgGroupWrapper) {
+                var container = renderer.box.parentNode, parents = [];
+                var htmlGroup, parentGroup;
+                this.parentGroup = svgGroupWrapper;
+                // Create a mock group to hold the HTML elements
+                if (svgGroupWrapper) {
+                    htmlGroup = svgGroupWrapper.div;
+                    if (!htmlGroup) {
+                        // Read the parent chain into an array and read from top
+                        // down
+                        parentGroup = svgGroupWrapper;
+                        while (parentGroup) {
+                            parents.push(parentGroup);
+                            // Move up to the next parent group
+                            parentGroup = parentGroup.parentGroup;
+                        }
+                        // Ensure dynamically updating position when any parent
+                        // is translated
+                        parents.reverse().forEach(function (parentGroup) {
+                            var cls = attr(parentGroup.element, 'class');
+                            /**
+                             * Common translate setter for X and Y on the HTML
+                             * group. Reverted the fix for #6957 du to
+                             * positioning problems and offline export (#7254,
+                             * #7280, #7529)
+                             * @private
+                             * @param {*} value
+                             * @param {string} key
+                                                     */
+                            function translateSetter(value, key) {
+                                parentGroup[key] = value;
+                                if (key === 'translateX') {
+                                    htmlGroupStyle.left = value + 'px';
+                                }
+                                else {
+                                    htmlGroupStyle.top = value + 'px';
+                                }
+                                parentGroup.doTransform = true;
+                            }
+                            // Create a HTML div and append it to the parent div
+                            // to emulate the SVG group structure
+                            var parentGroupStyles = parentGroup.styles || {};
+                            htmlGroup =
+                                parentGroup.div =
+                                    parentGroup.div || createElement('div', cls ? { className: cls } : void 0, {
+                                        position: 'absolute',
+                                        left: (parentGroup.translateX || 0) + 'px',
+                                        top: (parentGroup.translateY || 0) + 'px',
+                                        display: parentGroup.display,
+                                        opacity: parentGroup.opacity,
+                                        cursor: parentGroupStyles.cursor,
+                                        pointerEvents: (
+                                        // #5595
+                                        parentGroupStyles.pointerEvents),
+                                        visibility: parentGroup.visibility
+                                        // the top group is appended to container
+                                    }, htmlGroup || container);
+                            // Shortcut
+                            var htmlGroupStyle = htmlGroup.style;
+                            // Set listeners to update the HTML div's position
+                            // whenever the SVG group position is changed.
+                            extend(parentGroup, {
+                                // (#7287) Pass htmlGroup to use
+                                // the related group
+                                classSetter: (function (htmlGroup) {
+                                    return function (value) {
+                                        this.element.setAttribute('class', value);
+                                        htmlGroup.className = value;
+                                    };
+                                }(htmlGroup)),
+                                on: function () {
+                                    if (parents[0].div) { // #6418
+                                        wrapper.on.apply({
+                                            element: parents[0].div,
+                                            onEvents: parentGroup.onEvents
+                                        }, arguments);
+                                    }
+                                    return parentGroup;
+                                },
+                                translateXSetter: translateSetter,
+                                translateYSetter: translateSetter
+                            });
+                            if (!parentGroup.addedSetters) {
+                                addSetters(parentGroup);
+                            }
+                        });
+                    }
+                }
+                else {
+                    htmlGroup = container;
+                }
+                htmlGroup.appendChild(element);
+                // Shared with VML:
+                wrapper.added = true;
+                if (wrapper.alignOnAdd) {
+                    wrapper.htmlUpdateTransform();
+                }
+                return wrapper;
+            };
+        }
+        return wrapper;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    HTMLRenderer.composedClasses = [];
+    return HTMLRenderer;
+}(SVGRenderer));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default HTMLRenderer;

package/src/assets/plugins/highcharts/code/es-modules/Core/Renderer/RendererRegistry.js

@@ -0,0 +1,77 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import H from '../Globals.js';
+/* *
+ *
+ *  Namespace
+ *
+ * */
+var RendererRegistry;
+(function (RendererRegistry) {
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    RendererRegistry.rendererTypes = {};
+    /* *
+     *
+     *  Variables
+     *
+     * */
+    var defaultRenderer;
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Gets a registered renderer class. If no renderer type is provided or the
+     * requested renderer was not founded, the default renderer is returned.
+     *
+     * @param {string} [rendererType]
+     * Renderer type or the default renderer.
+     *
+     * @return {Highcharts.Class<Highcharts.SVGRenderer>}
+     * Returns the requested renderer class or the default renderer class.
+     */
+    function getRendererType(rendererType) {
+        if (rendererType === void 0) { rendererType = defaultRenderer; }
+        return (RendererRegistry.rendererTypes[rendererType] || RendererRegistry.rendererTypes[defaultRenderer]);
+    }
+    RendererRegistry.getRendererType = getRendererType;
+    /**
+     * Register a renderer class.
+     *
+     * @param {string} rendererType
+     * Renderer type to register.
+     *
+     * @param {Highcharts.Class<Highcharts.SVGRenderer>} rendererClass
+     * Returns the requested renderer class or the default renderer class.
+     *
+     * @param {boolean} setAsDefault
+     * Sets the renderer class as the default renderer.
+     */
+    function registerRendererType(rendererType, rendererClass, setAsDefault) {
+        RendererRegistry.rendererTypes[rendererType] = rendererClass;
+        if (!defaultRenderer || setAsDefault) {
+            defaultRenderer = rendererType;
+            H.Renderer = rendererClass; // compatibility
+        }
+    }
+    RendererRegistry.registerRendererType = registerRendererType;
+})(RendererRegistry || (RendererRegistry = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default RendererRegistry;