@highcharts/grid-pro 2.0.0

package/es-modules/Core/Renderer/RendererUtilities.js

@@ -0,0 +1,172 @@
+/* *
+ *
+ *  (c) 2010-2025 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Imports
+ *
+ * */
+import U from '../Utilities.js';
+const { clamp, pick, pushUnique, stableSort } = U;
+/* *
+ *
+ *  Namespace
+ *
+ * */
+var RendererUtilities;
+(function (RendererUtilities) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
+    /**
+     * General distribution algorithm for distributing labels of differing size
+     * along a confined length in two dimensions. The algorithm takes an array
+     * of objects containing a size, a target and a rank. It will place the
+     * labels as close as possible to their targets, skipping the lowest ranked
+     * labels if necessary.
+     * @private
+     */
+    function distribute(boxes, len, maxDistance) {
+        // Original array will be altered with added .pos
+        const origBoxes = boxes, reducedLen = origBoxes.reducedLen || len, sortByRank = (a, b) => (b.rank || 0) - (a.rank || 0), sortByTarget = (a, b) => a.target - b.target, restBoxes = [], // The outranked overshoot
+        boxesLength = boxes.length, forDeletion = [], push = restBoxes.push;
+        let i, cursor, step, overlapping = true, box, target, total = 0, equalRank;
+        // If the total size exceeds the len, remove those boxes with the lowest
+        // rank
+        i = boxesLength;
+        while (i--) {
+            total += boxes[i].size;
+        }
+        // Sort by rank, then slice away overshoot
+        if (total > reducedLen) {
+            stableSort(boxes, sortByRank);
+            equalRank = boxes[0].rank === boxes[boxes.length - 1].rank;
+            step = equalRank ? boxesLength / 2 : -1;
+            cursor = equalRank ? step : boxesLength - 1;
+            // When the boxes have equal rank (pie data labels, flags - #10073),
+            // decimate the boxes by starting in the middle and gradually remove
+            // more items inside the array. When they are sorted by rank, just
+            // remove the ones with the lowest rank from the end.
+            while (step && total > reducedLen) {
+                i = Math.floor(cursor);
+                box = boxes[i];
+                if (pushUnique(forDeletion, i)) {
+                    total -= box.size;
+                }
+                cursor += step;
+                // Start over the decimation with smaller steps
+                if (equalRank && cursor >= boxes.length) {
+                    step /= 2;
+                    cursor = step;
+                }
+            }
+            // Clean out the boxes marked for deletion
+            forDeletion
+                .sort((a, b) => b - a)
+                .forEach((i) => push.apply(restBoxes, boxes.splice(i, 1)));
+        }
+        // Order by target
+        stableSort(boxes, sortByTarget);
+        // So far we have been mutating the original array. Now
+        // create a copy with target arrays
+        boxes = boxes.map((box) => ({
+            size: box.size,
+            targets: [box.target],
+            align: pick(box.align, 0.5)
+        }));
+        while (overlapping) {
+            // Initial positions: target centered in box
+            i = boxes.length;
+            while (i--) {
+                box = boxes[i];
+                // Composite box, average of targets
+                target = (Math.min.apply(0, box.targets) +
+                    Math.max.apply(0, box.targets)) / 2;
+                box.pos = clamp(target - box.size * box.align, 0, len - box.size);
+            }
+            // Detect overlap and join boxes
+            i = boxes.length;
+            overlapping = false;
+            while (i--) {
+                // Overlap
+                if (i > 0 &&
+                    boxes[i - 1].pos + boxes[i - 1].size >
+                        boxes[i].pos) {
+                    // Add this size to the previous box
+                    boxes[i - 1].size += boxes[i].size;
+                    boxes[i - 1].targets = boxes[i - 1]
+                        .targets
+                        .concat(boxes[i].targets);
+                    boxes[i - 1].align = 0.5;
+                    // Overlapping right, push left
+                    if (boxes[i - 1].pos + boxes[i - 1].size > len) {
+                        boxes[i - 1].pos = len - boxes[i - 1].size;
+                    }
+                    boxes.splice(i, 1); // Remove this item
+                    overlapping = true;
+                }
+            }
+        }
+        // Add the rest (hidden boxes)
+        push.apply(origBoxes, restBoxes);
+        // Now the composite boxes are placed, we need to put the original boxes
+        // within them
+        i = 0;
+        boxes.some((box) => {
+            let posInCompositeBox = 0;
+            // Exceeded maxDistance => abort
+            return (box.targets || []).some(() => {
+                origBoxes[i].pos = box.pos + posInCompositeBox;
+                // If the distance between the position and the target exceeds
+                // maxDistance, abort the loop and decrease the length in
+                // increments of 10% to recursively reduce the number of
+                // visible boxes by rank. Once all boxes are within the
+                // maxDistance, we're good.
+                if (typeof maxDistance !== 'undefined' &&
+                    Math.abs(origBoxes[i].pos - origBoxes[i].target) > maxDistance) {
+                    // Reset the positions that are already set
+                    origBoxes
+                        .slice(0, i + 1)
+                        .forEach((box) => delete box.pos);
+                    // Try with a smaller length
+                    origBoxes.reducedLen =
+                        (origBoxes.reducedLen || len) - (len * 0.1);
+                    // Recurse
+                    if (origBoxes.reducedLen > len * 0.1) {
+                        distribute(origBoxes, len, maxDistance);
+                    }
+                    // Exceeded maxDistance => abort
+                    return true;
+                }
+                posInCompositeBox += origBoxes[i].size;
+                i++;
+                return false;
+            });
+        });
+        // Add the rest (hidden) boxes and sort by target
+        stableSort(origBoxes, sortByTarget);
+        return origBoxes;
+    }
+    RendererUtilities.distribute = distribute;
+})(RendererUtilities || (RendererUtilities = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default RendererUtilities;

package/es-modules/Core/Responsive.d.ts

@@ -0,0 +1,55 @@
+import type Chart from './Chart/Chart.js';
+import type GlobalOptions from './Options';
+declare module './Chart/ChartBase' {
+    interface ChartBase {
+        /** @requires Core/Responsive */
+        setResponsive(redraw?: boolean, reset?: boolean): void;
+    }
+}
+declare module './Options' {
+    interface Options {
+        isResponsiveOptions?: boolean;
+        responsive?: Responsive.Options;
+    }
+}
+declare namespace Responsive {
+    interface CallbackFunction {
+        (this: Chart): boolean;
+    }
+    class Composition extends Chart {
+        /** @requires Core/Responsive */
+        currentResponsive?: CurrentObject;
+        /** @requires Core/Responsive */
+        currentOptions(options: Partial<GlobalOptions>): Partial<GlobalOptions>;
+        /** @requires Core/Responsive */
+        matchResponsiveRule(rule: RuleOptions, matches: Array<string>): void;
+        /** @requires Core/Responsive */
+        setResponsive(redraw?: boolean, reset?: boolean): void;
+        updatingResponsive: boolean;
+    }
+    interface CurrentObject {
+        mergedOptions: Partial<GlobalOptions>;
+        ruleIds: string;
+        undoOptions: Partial<GlobalOptions>;
+    }
+    interface Options {
+        rules?: Array<RuleOptions>;
+    }
+    interface RuleConditionOptions {
+        callback?: CallbackFunction;
+        maxHeight?: number;
+        maxWidth?: number;
+        minHeight?: number;
+        minWidth?: number;
+    }
+    interface RuleOptions {
+        _id?: string;
+        chartOptions?: GlobalOptions;
+        condition: RuleConditionOptions;
+    }
+    /**
+     * @private
+     */
+    function compose<T extends typeof Chart>(ChartClass: T): (T & typeof Composition);
+}
+export default Responsive;

package/es-modules/Core/Responsive.js

@@ -0,0 +1,260 @@
+/* *
+ *
+ *  (c) 2010-2025 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import U from './Utilities.js';
+const { diffObjects, extend, find, merge, pick, uniqueKey } = U;
+/* *
+ *
+ *  Composition
+ *
+ * */
+var Responsive;
+(function (Responsive) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * @private
+     */
+    function compose(ChartClass) {
+        const chartProto = ChartClass.prototype;
+        if (!chartProto.matchResponsiveRule) {
+            extend(chartProto, {
+                matchResponsiveRule,
+                setResponsive
+            });
+        }
+        return ChartClass;
+    }
+    Responsive.compose = compose;
+    /**
+     * Handle a single responsiveness rule.
+     *
+     * @private
+     * @function Highcharts.Chart#matchResponsiveRule
+     * @param {Highcharts.ResponsiveRulesOptions} rule
+     * @param {Array<string>} matches
+     */
+    function matchResponsiveRule(rule, matches) {
+        const condition = rule.condition, fn = condition.callback || function () {
+            return (this.chartWidth <= pick(condition.maxWidth, Number.MAX_VALUE) &&
+                this.chartHeight <= pick(condition.maxHeight, Number.MAX_VALUE) &&
+                this.chartWidth >= pick(condition.minWidth, 0) &&
+                this.chartHeight >= pick(condition.minHeight, 0));
+        };
+        if (fn.call(this)) {
+            matches.push(rule._id);
+        }
+    }
+    /**
+     * Update the chart based on the current chart/document size and options
+     * for responsiveness.
+     *
+     * @private
+     * @function Highcharts.Chart#setResponsive
+     * @param  {boolean} [redraw=true]
+     * @param  {boolean} [reset=false]
+     * Reset by un-applying all rules. Chart.update resets all rules before
+     * applying updated options.
+     */
+    function setResponsive(redraw, reset) {
+        const options = this.options.responsive, currentResponsive = this.currentResponsive;
+        let ruleIds = [], undoOptions;
+        if (!reset && options && options.rules) {
+            options.rules.forEach((rule) => {
+                if (typeof rule._id === 'undefined') {
+                    rule._id = uniqueKey();
+                }
+                this.matchResponsiveRule(rule, ruleIds /* , redraw */);
+            }, this);
+        }
+        // Merge matching rules
+        const mergedOptions = merge(...ruleIds
+            .map((ruleId) => find(options?.rules || [], (rule) => (rule._id === ruleId)))
+            .map((rule) => rule?.chartOptions));
+        mergedOptions.isResponsiveOptions = true;
+        // Stringified key for the rules that currently apply.
+        ruleIds = (ruleIds.toString() || void 0);
+        const currentRuleIds = currentResponsive?.ruleIds;
+        // Changes in what rules apply
+        if (ruleIds !== currentRuleIds) {
+            // Undo previous rules. Before we apply a new set of rules, we
+            // need to roll back completely to base options (#6291).
+            if (currentResponsive) {
+                this.currentResponsive = void 0;
+                this.updatingResponsive = true;
+                this.update(currentResponsive.undoOptions, redraw, true);
+                this.updatingResponsive = false;
+            }
+            if (ruleIds) {
+                // Get undo-options for matching rules. The `undoOptions``
+                // hold the current values before they are changed by the
+                // `mergedOptions`.
+                undoOptions = diffObjects(mergedOptions, this.options, true, this.collectionsWithUpdate);
+                undoOptions.isResponsiveOptions = true;
+                this.currentResponsive = {
+                    ruleIds: ruleIds,
+                    mergedOptions: mergedOptions,
+                    undoOptions: undoOptions
+                };
+                if (!this.updatingResponsive) {
+                    this.update(mergedOptions, redraw, true);
+                }
+            }
+            else {
+                this.currentResponsive = void 0;
+            }
+        }
+    }
+})(Responsive || (Responsive = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default Responsive;
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * A callback function to gain complete control on when the responsive rule
+ * applies.
+ *
+ * @callback Highcharts.ResponsiveCallbackFunction
+ *
+ * @param {Highcharts.Chart} this
+ * Chart context.
+ *
+ * @return {boolean}
+ * Return `true` if it applies.
+ */
+(''); // Keeps doclets above in JS file
+/* *
+ *
+ *  API Options
+ *
+ * */
+/**
+ * Allows setting a set of rules to apply for different screen or chart
+ * sizes. Each rule specifies additional chart options.
+ *
+ * @sample {highstock} stock/demo/responsive/
+ *         Stock chart
+ * @sample highcharts/responsive/axis/
+ *         Axis
+ * @sample highcharts/responsive/legend/
+ *         Legend
+ * @sample highcharts/responsive/classname/
+ *         Class name
+ *
+ * @since     5.0.0
+ * @apioption responsive
+ */
+/**
+ * A set of rules for responsive settings. The rules are executed from
+ * the top down.
+ *
+ * @sample {highcharts} highcharts/responsive/axis/
+ *         Axis changes
+ * @sample {highstock} highcharts/responsive/axis/
+ *         Axis changes
+ * @sample {highmaps} highcharts/responsive/axis/
+ *         Axis changes
+ *
+ * @type      {Array<*>}
+ * @since     5.0.0
+ * @apioption responsive.rules
+ */
+/**
+ * A full set of chart options to apply as overrides to the general
+ * chart options. The chart options are applied when the given rule
+ * is active.
+ *
+ * A special case is configuration objects that take arrays, for example
+ * [xAxis](#xAxis), [yAxis](#yAxis) or [series](#series). For these
+ * collections, an `id` option is used to map the new option set to
+ * an existing object. If an existing object of the same id is not found,
+ * the item of the same index updated. So for example, setting `chartOptions`
+ * with two series items without an `id`, will cause the existing chart's
+ * two series to be updated with respective options.
+ *
+ * @sample {highstock} stock/demo/responsive/
+ *         Stock chart
+ * @sample highcharts/responsive/axis/
+ *         Axis
+ * @sample highcharts/responsive/legend/
+ *         Legend
+ * @sample highcharts/responsive/classname/
+ *         Class name
+ *
+ * @type      {Highcharts.Options}
+ * @since     5.0.0
+ * @apioption responsive.rules.chartOptions
+ */
+/**
+ * Under which conditions the rule applies.
+ *
+ * @since     5.0.0
+ * @apioption responsive.rules.condition
+ */
+/**
+ * A callback function to gain complete control on when the responsive
+ * rule applies. Return `true` if it applies. This opens for checking
+ * against other metrics than the chart size, for example the document
+ * size or other elements.
+ *
+ * @type      {Highcharts.ResponsiveCallbackFunction}
+ * @since     5.0.0
+ * @context   Highcharts.Chart
+ * @apioption responsive.rules.condition.callback
+ */
+/**
+ * The responsive rule applies if the chart height is less than this.
+ *
+ * @type      {number}
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.maxHeight
+ */
+/**
+ * The responsive rule applies if the chart width is less than this.
+ *
+ * @sample highcharts/responsive/axis/
+ *         Max width is 500
+ *
+ * @type      {number}
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.maxWidth
+ */
+/**
+ * The responsive rule applies if the chart height is greater than this.
+ *
+ * @type      {number}
+ * @default   0
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.minHeight
+ */
+/**
+ * The responsive rule applies if the chart width is greater than this.
+ *
+ * @type      {number}
+ * @default   0
+ * @since     5.0.0
+ * @apioption responsive.rules.condition.minWidth
+ */
+(''); // Keeps doclets above in JS file

package/es-modules/Core/Templating.d.ts

@@ -0,0 +1,125 @@
+import type TimeBase from '../Shared/TimeBase';
+import type { LangOptionsCore } from '../Shared/LangOptionsCore';
+/**
+ * Formats a JavaScript date timestamp (milliseconds since Jan 1st 1970) into a
+ * human readable date string. The format is a subset of the formats for PHP's
+ * [strftime](https://www.php.net/manual/en/function.strftime.php) function.
+ * Additional formats can be given in the {@link Highcharts.dateFormats} hook.
+ *
+ * Since v6.0.5, all internal dates are formatted through the
+ * {@link Highcharts.Chart#time} instance to respect chart-level time settings.
+ * The `Highcharts.dateFormat` function only reflects global time settings set
+ * with `setOptions`.
+ *
+ * Supported format keys:
+ * - `%a`: Short weekday, like 'Mon'
+ * - `%A`: Long weekday, like 'Monday'
+ * - `%d`: Two digit day of the month, 01 to 31
+ * - `%e`: Day of the month, 1 through 31
+ * - `%w`: Day of the week, 0 through 6
+ * - `%b`: Short month, like 'Jan'
+ * - `%B`: Long month, like 'January'
+ * - `%m`: Two digit month number, 01 through 12
+ * - `%y`: Two digits year, like 09 for 2009
+ * - `%Y`: Four digits year, like 2009
+ * - `%H`: Two digits hours in 24h format, 00 through 23
+ * - `%k`: Hours in 24h format, 0 through 23
+ * - `%I`: Two digits hours in 12h format, 00 through 11
+ * - `%l`: Hours in 12h format, 1 through 12
+ * - `%M`: Two digits minutes, 00 through 59
+ * - `%p`: Upper case AM or PM
+ * - `%P`: Lower case AM or PM
+ * - `%S`: Two digits seconds, 00 through 59
+ * - `%L`: Milliseconds (naming from Ruby)
+ *
+ * @function Highcharts.dateFormat
+ *
+ * @param {string} format
+ *        The desired format where various time representations are prefixed
+ *        with `%`.
+ *
+ * @param {number} timestamp
+ *        The JavaScript timestamp.
+ *
+ * @param {boolean} [upperCaseFirst=false]
+ *        Upper case first letter in the return.
+ *
+ * @return {string}
+ *         The formatted date.
+ */
+declare function dateFormat(format: string, timestamp: number, upperCaseFirst?: boolean): string;
+/**
+ * Format a string according to a subset of the rules of Python's String.format
+ * method.
+ *
+ * @example
+ * let s = Highcharts.format(
+ *     'The {color} fox was {len:.2f} feet long',
+ *     { color: 'red', len: Math.PI }
+ * );
+ * // => The red fox was 3.14 feet long
+ *
+ * @function Highcharts.format
+ *
+ * @param {string} str
+ *        The string to format.
+ *
+ * @param {Record<string, *>} ctx
+ *        The context, a collection of key-value pairs where each key is
+ *        replaced by its value.
+ *
+ * @param {Highcharts.Chart} [owner]
+ *        A `Chart` or `Grid` instance used to get numberFormatter and time.
+ *
+ * @return {string}
+ *         The formatted string.
+ */
+declare function format(str: string | undefined, ctx: any, owner?: Templating.Owner): string;
+/**
+ * Format a number and return a string based on input settings.
+ *
+ * @sample highcharts/members/highcharts-numberformat/
+ *         Custom number format
+ *
+ * @function Highcharts.numberFormat
+ *
+ * @param {number} number
+ *        The input number to format.
+ *
+ * @param {number} decimals
+ *        The amount of decimals. A value of -1 preserves the amount in the
+ *        input number.
+ *
+ * @param {string} [decimalPoint]
+ *        The decimal point, defaults to the one given in the lang options, or
+ *        a dot.
+ *
+ * @param {string} [thousandsSep]
+ *        The thousands separator, defaults to the one given in the lang
+ *        options, or a space character.
+ *
+ * @return {string}
+ *         The formatted number.
+ */
+declare function numberFormat(this: Templating.Owner | void, number: number, decimals: number, decimalPoint?: string, thousandsSep?: string): string;
+declare const Templating: {
+    dateFormat: typeof dateFormat;
+    format: typeof format;
+    helpers: Record<string, Function>;
+    numberFormat: typeof numberFormat;
+};
+declare namespace Templating {
+    interface FormatterCallback<T> {
+        (this: T): string;
+    }
+    interface OwnerOptions {
+        lang?: LangOptionsCore;
+    }
+    interface Owner {
+        options?: OwnerOptions;
+        time?: TimeBase;
+        numberFormatter?: Function;
+        locale?: string | string[];
+    }
+}
+export default Templating;