@highcharts/grid-pro 2.0.0

package/es-modules/Accessibility/Utils/HTMLUtilities.d.ts

@@ -0,0 +1,108 @@
+import type { DOMElementType, HTMLDOMElement } from '../../Core/Renderer/DOMElementType';
+/**
+ * @private
+ * @param {Highcharts.HTMLDOMElement} el
+ * @param {string} className
+ * @return {void}
+ */
+declare function addClass(el: HTMLDOMElement, className: string): void;
+/**
+ * @private
+ * @param {Highcharts.HTMLDOMElement} el
+ * @param {string} className
+ * @return {void}
+ */
+declare function removeClass(el: HTMLDOMElement, className: string): void;
+/**
+ * Utility function to clone a mouse event for re-dispatching.
+ * @private
+ */
+declare function cloneMouseEvent(e: MouseEvent): MouseEvent;
+/**
+ * Utility function to clone a touch event for re-dispatching.
+ * @private
+ */
+declare function cloneTouchEvent(e: TouchEvent): TouchEvent;
+/**
+ * @private
+ */
+declare function escapeStringForHTML(str: string): string;
+/**
+ * Get an element by ID
+ * @private
+ */
+declare function getElement(id: string): (DOMElementType | null);
+/**
+ * Get a fake mouse event of a given type. If relatedTarget is not given,
+ * it will point to simulatedEventTarget, as an indicator that the event
+ * is fake.
+ * @private
+ */
+declare function getFakeMouseEvent(type: string, position?: {
+    x: number;
+    y: number;
+}, relatedTarget?: EventTarget): MouseEvent;
+/**
+ * Get an appropriate heading level for an element. Corresponds to the
+ * heading level below the previous heading in the DOM.
+ *
+ * Note: Only detects previous headings in the DOM that are siblings,
+ * ancestors, or previous siblings of ancestors. Headings that are nested below
+ * siblings of ancestors (cousins et.al) are not picked up. This is because it
+ * is ambiguous whether or not the nesting is for layout purposes or indicates a
+ * separate section.
+ *
+ * @private
+ * @param {Highcharts.HTMLDOMElement} [element]
+ * @return {string} The heading tag name (h1, h2 etc).
+ * If no nearest heading is found, "p" is returned.
+ */
+declare function getHeadingTagNameForElement(element: HTMLDOMElement): string;
+/**
+ * Remove an element from the DOM.
+ * @private
+ * @param {Highcharts.HTMLDOMElement|Highcharts.SVGDOMElement} [element]
+ * @return {void}
+ */
+declare function removeElement(element?: DOMElementType): void;
+/**
+ * Remove all child nodes from an element.
+ * @private
+ * @param {Highcharts.HTMLDOMElement|Highcharts.SVGDOMElement} [element]
+ * @return {void}
+ */
+declare function removeChildNodes(element: DOMElementType): void;
+/**
+ * Utility function. Reverses child nodes of a DOM element.
+ * @private
+ */
+declare function reverseChildNodes(node: DOMElementType): void;
+/**
+ * Used for aria-label attributes, painting on a canvas will fail if the
+ * text contains tags.
+ * @private
+ */
+declare function stripHTMLTagsFromString(str: string, isForExport?: boolean): string;
+/**
+ * Utility function for hiding an element visually, but still keeping it
+ * available to screen reader users.
+ * @private
+ */
+declare function visuallyHideElement(element: HTMLDOMElement): void;
+declare const HTMLUtilities: {
+    addClass: typeof addClass;
+    cloneMouseEvent: typeof cloneMouseEvent;
+    cloneTouchEvent: typeof cloneTouchEvent;
+    escapeStringForHTML: typeof escapeStringForHTML;
+    getElement: typeof getElement;
+    getFakeMouseEvent: typeof getFakeMouseEvent;
+    getHeadingTagNameForElement: typeof getHeadingTagNameForElement;
+    removeChildNodes: typeof removeChildNodes;
+    removeClass: typeof removeClass;
+    removeElement: typeof removeElement;
+    reverseChildNodes: typeof reverseChildNodes;
+    simulatedEventTarget: EventTarget;
+    stripHTMLTagsFromString: typeof stripHTMLTagsFromString;
+    visuallyHideElement: typeof visuallyHideElement;
+};
+export default HTMLUtilities;

package/es-modules/Accessibility/Utils/HTMLUtilities.js

@@ -0,0 +1,319 @@
+/* *
+ *
+ *  (c) 2009-2025 Øystein Moseng
+ *
+ *  Utility functions for accessibility module.
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import H from '../../Core/Globals.js';
+const { doc, win } = H;
+import U from '../../Core/Utilities.js';
+const { css } = U;
+/* *
+ *
+ *  Constants
+ *
+ * */
+const simulatedEventTarget = win.EventTarget && new win.EventTarget() || 'none';
+/* *
+ *
+ *  Functions
+ *
+ * */
+/* eslint-disable valid-jsdoc */
+/**
+ * @private
+ * @param {Highcharts.HTMLDOMElement} el
+ * @param {string} className
+ * @return {void}
+ */
+function addClass(el, className) {
+    if (el.classList) {
+        el.classList.add(className);
+    }
+    else if (el.className.indexOf(className) < 0) {
+        // Note: Dumb check for class name exists, should be fine for practical
+        // use cases, but will return false positives if the element has a class
+        // that contains the className.
+        el.className += ' ' + className;
+    }
+}
+/**
+ * @private
+ * @param {Highcharts.HTMLDOMElement} el
+ * @param {string} className
+ * @return {void}
+ */
+function removeClass(el, className) {
+    if (el.classList) {
+        el.classList.remove(className);
+    }
+    else {
+        // Note: Dumb logic that will break if the element has a class name that
+        // consists of className plus something else.
+        el.className = el.className.replace(new RegExp(className, 'g'), '');
+    }
+}
+/**
+ * Utility function to clone a mouse event for re-dispatching.
+ * @private
+ */
+function cloneMouseEvent(e) {
+    if (typeof win.MouseEvent === 'function') {
+        return new win.MouseEvent(e.type, e);
+    }
+    // No MouseEvent support, try using initMouseEvent
+    if (doc?.createEvent) {
+        const evt = doc.createEvent('MouseEvent');
+        if (evt.initMouseEvent) {
+            evt.initMouseEvent(e.type, e.bubbles, // #10561, #12161
+            e.cancelable, e.view || win, e.detail, e.screenX, e.screenY, e.clientX, e.clientY, e.ctrlKey, e.altKey, e.shiftKey, e.metaKey, e.button, e.relatedTarget);
+            return evt;
+        }
+    }
+    return getFakeMouseEvent(e.type);
+}
+/**
+ * Utility function to clone a touch event for re-dispatching.
+ * @private
+ */
+function cloneTouchEvent(e) {
+    const touchListToTouchArray = (l) => {
+        const touchArray = [];
+        for (let i = 0; i < l.length; ++i) {
+            const item = l.item(i);
+            if (item) {
+                touchArray.push(item);
+            }
+        }
+        return touchArray;
+    };
+    if (typeof win.TouchEvent === 'function') {
+        const newEvent = new win.TouchEvent(e.type, {
+            touches: touchListToTouchArray(e.touches),
+            targetTouches: touchListToTouchArray(e.targetTouches),
+            changedTouches: touchListToTouchArray(e.changedTouches),
+            ctrlKey: e.ctrlKey,
+            shiftKey: e.shiftKey,
+            altKey: e.altKey,
+            metaKey: e.metaKey,
+            bubbles: e.bubbles,
+            cancelable: e.cancelable,
+            composed: e.composed,
+            detail: e.detail,
+            view: e.view
+        });
+        if (e.defaultPrevented) {
+            newEvent.preventDefault();
+        }
+        return newEvent;
+    }
+    const fakeEvt = cloneMouseEvent(e);
+    fakeEvt.touches = e.touches;
+    fakeEvt.changedTouches = e.changedTouches;
+    fakeEvt.targetTouches = e.targetTouches;
+    return fakeEvt;
+}
+/**
+ * @private
+ */
+function escapeStringForHTML(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#x27;')
+        .replace(/\//g, '&#x2F;');
+}
+/**
+ * Get an element by ID
+ * @private
+ */
+function getElement(id) {
+    return doc.getElementById(id);
+}
+/**
+ * Get a fake mouse event of a given type. If relatedTarget is not given,
+ * it will point to simulatedEventTarget, as an indicator that the event
+ * is fake.
+ * @private
+ */
+function getFakeMouseEvent(type, position, relatedTarget) {
+    const pos = position || {
+        x: 0,
+        y: 0
+    };
+    if (typeof win.MouseEvent === 'function') {
+        return new win.MouseEvent(type, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            button: 0,
+            buttons: 1,
+            relatedTarget: relatedTarget || simulatedEventTarget,
+            view: win,
+            detail: type === 'click' ? 1 : 0,
+            screenX: pos.x,
+            screenY: pos.y,
+            clientX: pos.x,
+            clientY: pos.y
+        });
+    }
+    // No MouseEvent support, try using initMouseEvent
+    if (doc?.createEvent) {
+        const evt = doc.createEvent('MouseEvent');
+        if (evt.initMouseEvent) {
+            evt.initMouseEvent(type, true, // Bubble
+            true, // Cancel
+            win, // View
+            type === 'click' ? 1 : 0, // Detail
+            // Coords
+            pos.x, pos.y, pos.x, pos.y, 
+            // Pressed keys
+            false, false, false, false, 0, // Button
+            null // Related target
+            );
+            return evt;
+        }
+    }
+    return { type: type };
+}
+/**
+ * Get an appropriate heading level for an element. Corresponds to the
+ * heading level below the previous heading in the DOM.
+ *
+ * Note: Only detects previous headings in the DOM that are siblings,
+ * ancestors, or previous siblings of ancestors. Headings that are nested below
+ * siblings of ancestors (cousins et.al) are not picked up. This is because it
+ * is ambiguous whether or not the nesting is for layout purposes or indicates a
+ * separate section.
+ *
+ * @private
+ * @param {Highcharts.HTMLDOMElement} [element]
+ * @return {string} The heading tag name (h1, h2 etc).
+ * If no nearest heading is found, "p" is returned.
+ */
+function getHeadingTagNameForElement(element) {
+    const getIncreasedHeadingLevel = (tagName) => {
+        const headingLevel = parseInt(tagName.slice(1), 10), newLevel = Math.min(6, headingLevel + 1);
+        return 'h' + newLevel;
+    };
+    const isHeading = (tagName) => /^H[1-6]$/i.test(tagName);
+    const getPreviousSiblingsHeading = (el) => {
+        let sibling = el;
+        while (sibling = sibling.previousSibling) { // eslint-disable-line
+            const tagName = sibling.tagName || '';
+            if (isHeading(tagName)) {
+                return tagName;
+            }
+        }
+        return '';
+    };
+    const getHeadingRecursive = (el) => {
+        const prevSiblingsHeading = getPreviousSiblingsHeading(el);
+        if (prevSiblingsHeading) {
+            return getIncreasedHeadingLevel(prevSiblingsHeading);
+        }
+        // No previous siblings are headings, try parent node
+        const parent = el.parentElement;
+        if (!parent) {
+            return 'h6';
+        }
+        const parentTagName = parent.tagName;
+        if (isHeading(parentTagName)) {
+            return getIncreasedHeadingLevel(parentTagName);
+        }
+        return getHeadingRecursive(parent);
+    };
+    return getHeadingRecursive(element);
+}
+/**
+ * Remove an element from the DOM.
+ * @private
+ * @param {Highcharts.HTMLDOMElement|Highcharts.SVGDOMElement} [element]
+ * @return {void}
+ */
+function removeElement(element) {
+    if (element && element.parentNode) {
+        element.parentNode.removeChild(element);
+    }
+}
+/**
+ * Remove all child nodes from an element.
+ * @private
+ * @param {Highcharts.HTMLDOMElement|Highcharts.SVGDOMElement} [element]
+ * @return {void}
+ */
+function removeChildNodes(element) {
+    while (element.lastChild) {
+        element.removeChild(element.lastChild);
+    }
+}
+/**
+ * Utility function. Reverses child nodes of a DOM element.
+ * @private
+ */
+function reverseChildNodes(node) {
+    let i = node.childNodes.length;
+    while (i--) {
+        node.appendChild(node.childNodes[i]);
+    }
+}
+/**
+ * Used for aria-label attributes, painting on a canvas will fail if the
+ * text contains tags.
+ * @private
+ */
+function stripHTMLTagsFromString(str, isForExport = false) {
+    return (typeof str === 'string') ?
+        (isForExport ?
+            str.replace(/<\/?[^>]+(>|$)/g, '') :
+            str.replace(/<\/?(?!\s)[^>]+(>|$)/g, '')) : str;
+}
+/**
+ * Utility function for hiding an element visually, but still keeping it
+ * available to screen reader users.
+ * @private
+ */
+function visuallyHideElement(element) {
+    css(element, {
+        position: 'absolute',
+        width: '1px',
+        height: '1px',
+        overflow: 'hidden',
+        whiteSpace: 'nowrap',
+        clip: 'rect(1px, 1px, 1px, 1px)',
+        marginTop: '-3px',
+        '-ms-filter': 'progid:DXImageTransform.Microsoft.Alpha(Opacity=1)',
+        filter: 'alpha(opacity=1)',
+        opacity: 0.01
+    });
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+const HTMLUtilities = {
+    addClass,
+    cloneMouseEvent,
+    cloneTouchEvent,
+    escapeStringForHTML,
+    getElement,
+    getFakeMouseEvent,
+    getHeadingTagNameForElement,
+    removeChildNodes,
+    removeClass,
+    removeElement,
+    reverseChildNodes,
+    simulatedEventTarget,
+    stripHTMLTagsFromString,
+    visuallyHideElement
+};
+export default HTMLUtilities;

package/es-modules/Core/Animation/AnimationUtilities.d.ts

@@ -0,0 +1,107 @@
+import type AnimationOptions from './AnimationOptions';
+import type Chart from '../Chart/Chart';
+import type CSSObject from '../Renderer/CSSObject';
+import type { DeepPartial } from '../../Shared/Types';
+import type { HTMLDOMElement } from '../Renderer/DOMElementType';
+import type Series from '../Series/Series';
+import type SVGAttributes from '../Renderer/SVG/SVGAttributes';
+import type SVGElement from '../Renderer/SVG/SVGElement';
+/**
+ * Set the global animation to either a given value, or fall back to the given
+ * chart's animation option.
+ *
+ * @function Highcharts.setAnimation
+ *
+ * @param {boolean|Partial<Highcharts.AnimationOptionsObject>|undefined} animation
+ *        The animation object.
+ *
+ * @param {Highcharts.Chart} chart
+ *        The chart instance.
+ *
+ * @todo
+ * This function always relates to a chart, and sets a property on the renderer,
+ * so it should be moved to the SVGRenderer.
+ */
+declare function setAnimation(animation: (boolean | Partial<AnimationOptions> | undefined), chart: Chart): void;
+/**
+ * Get the animation in object form, where a disabled animation is always
+ * returned as `{ duration: 0 }`.
+ *
+ * @function Highcharts.animObject
+ *
+ * @param {boolean|Highcharts.AnimationOptionsObject} [animation=0]
+ *        An animation setting. Can be an object with duration, complete and
+ *        easing properties, or a boolean to enable or disable.
+ *
+ * @return {Highcharts.AnimationOptionsObject}
+ *         An object with at least a duration property.
+ */
+declare function animObject(animation?: (boolean | DeepPartial<AnimationOptions>)): AnimationOptions;
+/**
+ * Get the defer as a number value from series animation options.
+ *
+ * @function Highcharts.getDeferredAnimation
+ *
+ * @param {Highcharts.Chart} chart
+ *        The chart instance.
+ *
+ * @param {boolean|Highcharts.AnimationOptionsObject} animation
+ *        An animation setting. Can be an object with duration, complete and
+ *        easing properties, or a boolean to enable or disable.
+ *
+ * @param {Highcharts.Series} [series]
+ *        Series to defer animation.
+ *
+ * @return {number}
+ *        The numeric value.
+ */
+declare function getDeferredAnimation(chart: Chart, animation: (boolean | Partial<AnimationOptions> | undefined), series?: Series): Partial<AnimationOptions>;
+/**
+ * The global animate method, which uses Fx to create individual animators.
+ *
+ * @function Highcharts.animate
+ *
+ * @param {Highcharts.HTMLDOMElement|Highcharts.SVGElement} el
+ *        The element to animate.
+ *
+ * @param {Highcharts.CSSObject|Highcharts.SVGAttributes} params
+ *        An object containing key-value pairs of the properties to animate.
+ *        Supports numeric as pixel-based CSS properties for HTML objects and
+ *        attributes for SVGElements.
+ *
+ * @param {Partial<Highcharts.AnimationOptionsObject>} [opt]
+ *        Animation options.
+ *
+ * @return {void}
+ */
+declare function animate(el: (HTMLDOMElement | SVGElement), params: (CSSObject | SVGAttributes), opt?: boolean | Partial<AnimationOptions>): void;
+/**
+ * Stop running animation.
+ *
+ * @function Highcharts.stop
+ *
+ * @param {Highcharts.SVGElement} el
+ *        The SVGElement to stop animation on.
+ *
+ * @param {string} [prop]
+ *        The property to stop animating. If given, the stop method will stop a
+ *        single property from animating, while others continue.
+ *
+ * @return {void}
+ *
+ * @todo
+ * A possible extension to this would be to stop a single property, when
+ * we want to continue animating others. Then assign the prop to the timer
+ * in the Fx.run method, and check for the prop here. This would be an
+ * improvement in all cases where we stop the animation from .attr. Instead of
+ * stopping everything, we can just stop the actual attributes we're setting.
+ */
+declare function stop(el: SVGElement | HTMLElement, prop?: string): void;
+declare const animationExports: {
+    animate: typeof animate;
+    animObject: typeof animObject;
+    getDeferredAnimation: typeof getDeferredAnimation;
+    setAnimation: typeof setAnimation;
+    stop: typeof stop;
+};
+export default animationExports;