cx 26.0.1 → 26.0.2

package/build/charts/axis/CategoryAxis.d.ts

@@ -0,0 +1,35 @@
+/** @jsxImportSource react */
+import { Axis, AxisConfig, AxisInstance } from "./Axis";
+import { RenderingContext } from "../../ui/RenderingContext";
+import { BooleanProp, NumberProp, StringProp, Prop } from "../../ui/Prop";
+import { Binding } from "../../data/Binding";
+import { GetSet } from "../../ui/Prop";
+import { AccessorChain } from "../../data/createAccessorModelProxy";
+export interface CategoryAxisConfig extends AxisConfig {
+    /** Uniform axes provide exact size and offset for all entries. */
+    uniform?: BooleanProp;
+    /** Names corresponding the given `values`. */
+    names?: Prop<any[] | Record<string, any>>;
+    /** Values used to initialize the axis. */
+    values?: Prop<any[] | Record<string, any>>;
+    /** Min number of entries. */
+    minSize?: NumberProp;
+    /** Base CSS class. Defaults to `categoryaxis`. */
+    baseClass?: string;
+    /** Output value for category count. */
+    categoryCount?: Binding | AccessorChain<number> | GetSet<number>;
+    /** Show ticks aligned with gridlines. */
+    useGridlineTicks?: boolean;
+    /** Additional label formatting. */
+    format?: StringProp;
+}
+export declare class CategoryAxis extends Axis {
+    uniform: boolean;
+    minSize: number;
+    constructor(config: CategoryAxisConfig);
+    declareData(...args: any[]): void;
+    initInstance(context: RenderingContext, instance: AxisInstance): void;
+    explore(context: RenderingContext, instance: AxisInstance): void;
+    reportData(context: RenderingContext, instance: AxisInstance): void;
+    render(context: RenderingContext, instance: AxisInstance, key: string): React.ReactNode;
+}

package/build/charts/axis/CategoryAxis.js

@@ -0,0 +1,240 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** @jsxImportSource react */
+import { Axis } from "./Axis";
+import { isUndefined } from "../../util/isUndefined";
+import { isArray } from "../../util/isArray";
+import { Format } from "../../util/Format";
+export class CategoryAxis extends Axis {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData({
+            inverted: undefined,
+            uniform: undefined,
+            names: undefined,
+            values: undefined,
+            minSize: undefined,
+            categoryCount: undefined,
+            format: undefined,
+        }, ...args);
+    }
+    initInstance(context, instance) {
+        instance.calculator = new CategoryScale();
+    }
+    explore(context, instance) {
+        super.explore(context, instance);
+        var { values, names, inverted, uniform, minSize } = instance.data;
+        instance.calculator.reset(inverted, uniform, values, names, minSize, this.minTickDistance, this.minLabelDistance);
+    }
+    reportData(context, instance) {
+        instance.set("categoryCount", instance.calculator.valueList.length);
+    }
+    render(context, instance, key) {
+        var { data, calculator } = instance;
+        if (!data.bounds.valid())
+            return null;
+        let labelGetter = (v) => calculator.names[v] ?? v;
+        let labelFormatter = labelGetter;
+        if (data.format) {
+            let formatter = Format.parse(data.format);
+            labelFormatter = (v) => formatter(labelGetter(v));
+        }
+        return (_jsx("g", { className: data.classNames, style: data.style, children: this.renderTicksAndLabels(context, instance, labelFormatter, this.minLabelDistance) }, key));
+    }
+}
+CategoryAxis.prototype.baseClass = "categoryaxis";
+CategoryAxis.prototype.anchors = "0 1 1 0";
+CategoryAxis.prototype.vertical = false;
+CategoryAxis.prototype.inverted = false;
+CategoryAxis.prototype.uniform = false;
+CategoryAxis.prototype.labelOffset = 10;
+CategoryAxis.prototype.labelRotation = 0;
+CategoryAxis.prototype.labelAnchor = "auto";
+CategoryAxis.prototype.labelDx = "auto";
+CategoryAxis.prototype.labelDy = "auto";
+CategoryAxis.prototype.minSize = 1;
+CategoryAxis.prototype.minLabelDistanceHorizontal = 0;
+CategoryAxis.prototype.minLabelDistanceVertical = 0;
+CategoryAxis.prototype.minTickDistance = 0;
+Axis.alias("category", CategoryAxis);
+class CategoryScale {
+    padding;
+    min;
+    max;
+    minValue;
+    maxValue;
+    minSize;
+    valuesMap;
+    valueList;
+    inverted;
+    uniform;
+    valueStacks;
+    names;
+    minTickDistance;
+    minLabelDistance;
+    origin;
+    factor;
+    tickSizes;
+    a;
+    b;
+    shouldUpdate;
+    reset(inverted, uniform, values, names, minSize, minTickDistance, minLabelDistance) {
+        this.padding = 0.5;
+        this.min = undefined;
+        this.max = undefined;
+        this.minValue = undefined;
+        this.maxValue = undefined;
+        this.minSize = minSize;
+        this.valuesMap = {};
+        this.valueList = [];
+        this.inverted = inverted;
+        this.uniform = uniform;
+        this.valueStacks = {};
+        this.names = {};
+        this.minTickDistance = minTickDistance;
+        this.minLabelDistance = minLabelDistance;
+        if (values) {
+            if (isArray(values))
+                values.forEach((v) => this.acknowledge(v));
+            else if (typeof values == "object")
+                for (var k in values) {
+                    this.acknowledge(k);
+                    this.names[k] = values[k];
+                }
+        }
+        if (names) {
+            if (isArray(names)) {
+                values = values || [];
+                names.forEach((name, index) => {
+                    var value = values[index];
+                    this.names[value != null ? value : index] = name;
+                });
+            }
+            else
+                this.names = names;
+        }
+    }
+    decodeValue(n) {
+        return n;
+    }
+    encodeValue(v) {
+        return v;
+    }
+    map(v, offset = 0) {
+        var index = this.valuesMap[v] || 0;
+        return this.origin + (index + offset - this.min + this.padding) * this.factor;
+    }
+    measure(a, b) {
+        this.a = a;
+        this.b = b;
+        if (this.min == null)
+            this.min = this.minValue || 0;
+        if (this.max == null)
+            this.max = this.maxValue != null && !isNaN(this.maxValue) ? this.maxValue : 100;
+        var sign = this.inverted ? -1 : 1;
+        if (this.max - this.min + 1 < this.minSize) {
+            this.factor = (sign * (this.b - this.a)) / this.minSize;
+            this.origin = (this.b + this.a) * 0.5 - (this.factor * (this.max - this.min + 1)) / 2;
+        }
+        else {
+            this.factor = (sign * (this.b - this.a)) / (this.max - this.min + 2 * this.padding);
+            this.origin = (this.a * (1 + sign)) / 2 + (this.b * (1 - sign)) / 2; //a || b
+        }
+        this.tickSizes = [];
+        let tickMultiplier = [1, 2, 5];
+        let absFactor = Math.abs(this.factor);
+        for (let base = 1; base < 10000 && this.tickSizes.length < 2; base *= 10) {
+            for (let m of tickMultiplier) {
+                if (base * m * absFactor >= this.minTickDistance && this.tickSizes.length == 0)
+                    this.tickSizes.push(base * m);
+                if (base * m * absFactor >= this.minLabelDistance) {
+                    this.tickSizes.push(base * m);
+                    break;
+                }
+            }
+        }
+    }
+    hash() {
+        return {
+            origin: this.origin,
+            factor: this.factor,
+            min: this.min,
+            minSize: this.minSize,
+            padding: this.padding,
+            values: this.valueList.join(":"),
+            names: JSON.stringify(this.names),
+        };
+    }
+    isSame(x) {
+        var h = this.hash();
+        var same = x && !Object.keys(h).some((k) => x[k] !== h[k]);
+        this.shouldUpdate = !same;
+        return same;
+    }
+    acknowledge(value, width = 0, offset = 0) {
+        var index = this.valuesMap[value];
+        if (isUndefined(index)) {
+            index = this.valueList.length;
+            this.valueList.push(value);
+            this.valuesMap[value] = index;
+        }
+        if (this.minValue == null || index < this.minValue) {
+            this.minValue = index;
+            this.padding = Math.max(this.padding, Math.abs(offset - width / 2));
+        }
+        if (this.maxValue == null || index > this.maxValue) {
+            this.maxValue = index;
+            this.padding = Math.max(this.padding, Math.abs(offset + width / 2));
+        }
+    }
+    book(value, name) {
+        if (this.uniform)
+            value = 0;
+        var stack = this.valueStacks[value];
+        if (!stack)
+            stack = this.valueStacks[value] = {
+                index: {},
+                count: 0,
+            };
+        if (!stack.index.hasOwnProperty(name))
+            stack.index[name] = stack.count++;
+    }
+    locate(value, name) {
+        if (this.uniform)
+            value = 0;
+        var stack = this.valueStacks[value];
+        if (!stack)
+            return [0, 1];
+        return [stack.index[name], stack.count];
+    }
+    trackValue(v, offset = 0, constrain = false) {
+        let index = Math.round((v - this.origin) / this.factor - offset + this.min - this.padding);
+        if (index < this.min)
+            index = this.min;
+        if (index > this.max)
+            index = this.max;
+        return this.valueList[index];
+    }
+    findTickSize(minPxDist) {
+        for (let tickSize of this.tickSizes)
+            if (tickSize * Math.abs(this.factor) >= minPxDist)
+                return tickSize;
+        return 1;
+    }
+    getTickSizes() {
+        return this.tickSizes;
+    }
+    getTicks(tickSizes) {
+        return tickSizes.map((size) => this.valueList.filter((_, i) => i % size == 0));
+    }
+    mapGridlines() {
+        let result = [];
+        if (this.tickSizes.length == 0)
+            return result;
+        let step = this.tickSizes[0];
+        for (let index = this.min; index <= this.max + 1; index += step)
+            result.push(this.origin + (index - 0.5 - this.min + this.padding) * this.factor);
+        return result;
+    }
+}

package/build/charts/axis/NumericAxis.d.ts

@@ -0,0 +1,57 @@
+/** @jsxImportSource react */
+import { Axis, AxisConfig, AxisInstance } from "./Axis";
+import { RenderingContext } from "../../ui/RenderingContext";
+import { NumberProp, BooleanProp, StringProp } from "../../ui/Prop";
+export interface NumericAxisConfig extends AxisConfig {
+    /** Minimum value. */
+    min?: NumberProp;
+    /** Maximum value. */
+    max?: NumberProp;
+    /** Set to `true` to normalize the input range. */
+    normalized?: BooleanProp;
+    /** Number used to divide values before rendering axis labels. Default value is `1`. */
+    labelDivisor?: NumberProp;
+    /** Base CSS class to be applied to the element. Defaults to `numericaxis`. */
+    baseClass?: string;
+    tickDivisions?: Array<number[]>;
+    /** A number ranged between `0-2`. `0` means that the range is aligned with the lowest ticks. Default value is `1`, which means that the range is aligned with medium ticks. Use value `2` to align with major ticks. */
+    snapToTicks?: 0 | 1 | 2;
+    /** Value format. Default is `n`. */
+    format?: StringProp;
+    /** Size of a zone reserved for labels for both lower and upper end of the axis. */
+    deadZone?: NumberProp;
+    /** Size of a zone reserved for labels near the upper (higher) end of the axis.  */
+    upperDeadZone?: NumberProp;
+    /** Size of a zone reserved for labels near the lower end of the axis.   */
+    lowerDeadZone?: NumberProp;
+    /** Specifies minimum value increment between labels. Useful when formatting is not flexible enough, i.e. set to 1 for integer axes to avoid duplicate labels. */
+    minLabelTickSize?: number;
+    minTickStep?: number;
+}
+export declare class NumericAxis extends Axis {
+    deadZone: number;
+    lowerDeadZone: number;
+    upperDeadZone: number;
+    snapToTicks: number;
+    tickDivisions: number[][];
+    minLabelTickSize: number;
+    minTickStep: number;
+    format: string;
+    labelDivisor: number;
+    normalized: boolean;
+    constructor(config: NumericAxisConfig);
+    init(): void;
+    declareData(...args: any[]): void;
+    initInstance(context: RenderingContext, instance: AxisInstance): void;
+    explore(context: RenderingContext, instance: AxisInstance): void;
+    render(context: RenderingContext, instance: AxisInstance, key: string): React.ReactNode;
+    static XY(): {
+        x: {
+            type: typeof NumericAxis;
+        };
+        y: {
+            type: typeof NumericAxis;
+            vertical: boolean;
+        };
+    };
+}

package/build/charts/axis/NumericAxis.js

@@ -0,0 +1,316 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** @jsxImportSource react */
+import { Axis } from "./Axis";
+import { Stack } from "./Stack";
+import { Format } from "../../util/Format";
+import { isNumber } from "../../util/isNumber";
+import { Console } from "../../util/Console";
+export class NumericAxis extends Axis {
+    constructor(config) {
+        super(config);
+    }
+    init() {
+        if (this.deadZone) {
+            this.lowerDeadZone = this.deadZone;
+            this.upperDeadZone = this.deadZone;
+        }
+        super.init();
+    }
+    declareData(...args) {
+        super.declareData({
+            min: undefined,
+            max: undefined,
+            normalized: undefined,
+            inverted: undefined,
+            labelDivisor: undefined,
+            format: undefined,
+            lowerDeadZone: undefined,
+            upperDeadZone: undefined,
+        }, ...args);
+    }
+    initInstance(context, instance) {
+        instance.calculator = new NumericScale();
+    }
+    explore(context, instance) {
+        super.explore(context, instance);
+        let { min, max, normalized, inverted, lowerDeadZone, upperDeadZone } = instance.data;
+        instance.calculator.reset(min, max, this.snapToTicks, this.tickDivisions, this.minTickDistance, this.minTickStep, this.minLabelDistance, this.minLabelTickSize, normalized, inverted, lowerDeadZone, upperDeadZone);
+    }
+    render(context, instance, key) {
+        let { data } = instance;
+        if (!data.bounds.valid())
+            return null;
+        let baseFormatter = Format.parse(data.format);
+        let formatter = data.labelDivisor != 1 ? (v) => baseFormatter(v / data.labelDivisor) : baseFormatter;
+        return (_jsx("g", { className: data.classNames, style: data.style, children: this.renderTicksAndLabels(context, instance, formatter, this.minLabelDistance) }, key));
+    }
+    static XY() {
+        return {
+            x: { type: NumericAxis },
+            y: { type: NumericAxis, vertical: true },
+        };
+    }
+}
+NumericAxis.prototype.baseClass = "numericaxis";
+NumericAxis.prototype.tickDivisions = [
+    [1, 2, 10, 20, 100],
+    [1, 5, 10, 20, 100],
+];
+NumericAxis.prototype.snapToTicks = 1;
+NumericAxis.prototype.normalized = false;
+NumericAxis.prototype.format = "n";
+NumericAxis.prototype.labelDivisor = 1;
+NumericAxis.prototype.minLabelTickSize = 0;
+NumericAxis.prototype.minTickStep = 0;
+Axis.alias("numeric", NumericAxis);
+class NumericScale {
+    min;
+    max;
+    snapToTicks;
+    tickDivisions;
+    minLabelDistance;
+    minLabelTickSize;
+    minTickDistance;
+    minTickStep;
+    tickSizes;
+    normalized;
+    inverted;
+    minValue;
+    maxValue;
+    minValuePadded;
+    maxValuePadded;
+    stacks;
+    lowerDeadZone;
+    upperDeadZone;
+    origin;
+    scale;
+    a;
+    b;
+    shouldUpdate;
+    reset(min, max, snapToTicks, tickDivisions, minTickDistance, minTickStep, minLabelDistance, minLabelTickSize, normalized, inverted, lowerDeadZone, upperDeadZone) {
+        this.min = min;
+        this.max = max;
+        this.snapToTicks = snapToTicks;
+        this.tickDivisions = tickDivisions;
+        this.minLabelDistance = minLabelDistance;
+        this.minLabelTickSize = minLabelTickSize;
+        this.minTickDistance = minTickDistance;
+        this.minTickStep = minTickStep;
+        this.tickSizes = [];
+        this.normalized = normalized;
+        this.inverted = inverted;
+        delete this.minValue;
+        delete this.maxValue;
+        this.stacks = {};
+        this.lowerDeadZone = lowerDeadZone || 0;
+        this.upperDeadZone = upperDeadZone || 0;
+    }
+    map(v, offset = 0) {
+        return this.origin + (v + offset - this.scale.min + this.scale.minPadding) * this.scale.factor;
+    }
+    decodeValue(n) {
+        return n;
+    }
+    encodeValue(v) {
+        return v;
+    }
+    constrainValue(v) {
+        return Math.max(this.scale.min, Math.min(this.scale.max, v));
+    }
+    trackValue(v, offset = 0, constrain = false) {
+        let value = (v - this.origin) / this.scale.factor - offset + this.scale.min - this.scale.minPadding;
+        if (constrain)
+            value = this.constrainValue(v);
+        return value;
+    }
+    hash() {
+        let r = {
+            origin: this.origin,
+            factor: this.scale.factor,
+            min: this.scale.min,
+            max: this.scale.max,
+            minPadding: this.scale.minPadding,
+            maxPadding: this.scale.maxPadding,
+        };
+        r.stacks = Object.keys(this.stacks)
+            .map((s) => this.stacks[s].info?.join(","))
+            .join(":");
+        return r;
+    }
+    isSame(x) {
+        let hash = this.hash();
+        let same = x && !Object.keys(hash).some((k) => x[k] !== hash[k]);
+        this.shouldUpdate = !same;
+        return same;
+    }
+    measure(a, b) {
+        this.a = a;
+        this.b = b;
+        if (this.minValue != null && this.min == null)
+            this.min = this.minValue;
+        if (this.maxValue != null && this.max == null)
+            this.max = this.maxValue;
+        for (let s in this.stacks) {
+            let info = this.stacks[s].measure(this.normalized);
+            let [min, max] = info;
+            if (this.min == null || min < this.min)
+                this.min = min;
+            if (this.max == null || max > this.max)
+                this.max = max;
+            this.stacks[s].info = info;
+        }
+        if (this.min == null)
+            this.min = 0;
+        if (this.max == null)
+            this.max = this.normalized ? 1 : 100;
+        if (this.min == this.max) {
+            if (this.min == 0) {
+                this.min = -1;
+                this.max = 1;
+            }
+            else {
+                let delta = Math.abs(this.min) * 0.1;
+                this.min -= delta;
+                this.max += delta;
+            }
+        }
+        this.origin = this.inverted ? this.b : this.a;
+        this.scale = this.getScale();
+        this.calculateTicks();
+    }
+    getScale(tickSizes) {
+        let { min, max } = this;
+        let smin = min;
+        let smax = max;
+        let tickSize;
+        if (tickSizes && isNumber(this.snapToTicks) && tickSizes.length > 0) {
+            tickSize = tickSizes[Math.min(tickSizes.length - 1, this.snapToTicks)];
+            smin = Math.floor(smin / tickSize) * tickSize;
+            smax = Math.ceil(smax / tickSize) * tickSize;
+        }
+        else {
+            if (this.minValue === min)
+                smin = this.minValuePadded;
+            if (this.maxValue === max)
+                smax = this.maxValuePadded;
+        }
+        let minPadding = this.minValue === min ? Math.max(0, smin - this.minValuePadded) : 0;
+        let maxPadding = this.maxValue === max ? Math.max(0, this.maxValuePadded - smax) : 0;
+        let sign = this.b > this.a ? 1 : -1;
+        let factor = smin < smax
+            ? (Math.abs(this.b - this.a) - this.lowerDeadZone - this.upperDeadZone) /
+                (smax - smin + minPadding + maxPadding)
+            : 0;
+        if (factor < 0)
+            factor = 0;
+        if (factor > 0 && (this.lowerDeadZone > 0 || this.upperDeadZone > 0)) {
+            while (factor * (min - smin) < this.lowerDeadZone)
+                smin -= this.lowerDeadZone / factor;
+            while (factor * (smax - max) < this.upperDeadZone)
+                smax += this.upperDeadZone / factor;
+            if (tickSize > 0 && isNumber(this.snapToTicks)) {
+                smin = Math.floor(smin / tickSize) * tickSize;
+                smax = Math.ceil(smax / tickSize) * tickSize;
+                minPadding = this.minValue === min ? Math.max(0, smin - this.minValuePadded) : 0;
+                maxPadding = this.maxValue === max ? Math.max(0, this.maxValuePadded - smax) : 0;
+            }
+            factor = smin < smax ? Math.abs(this.b - this.a) / (smax - smin + minPadding + maxPadding) : 0;
+        }
+        return {
+            factor: sign * (this.inverted ? -factor : factor),
+            min: smin,
+            max: smax,
+            minPadding,
+            maxPadding,
+        };
+    }
+    acknowledge(value, width = 0, offset = 0) {
+        if (value == null)
+            return;
+        if (this.minValue == null || value < this.minValue) {
+            this.minValue = value;
+            this.minValuePadded = value + offset - width / 2;
+        }
+        if (this.maxValue == null || value > this.maxValue) {
+            this.maxValue = value;
+            this.maxValuePadded = value + offset + width / 2;
+        }
+    }
+    getStack(name) {
+        let s = this.stacks[name];
+        if (!s)
+            s = this.stacks[name] = new Stack();
+        return s;
+    }
+    stacknowledge(name, ordinal, value) {
+        return this.getStack(name).acknowledge(ordinal, value);
+    }
+    stack(name, ordinal, value) {
+        let v = this.getStack(name).stack(ordinal, value);
+        return v != null ? this.map(v) : null;
+    }
+    findTickSize(minPxDist) {
+        return this.tickSizes.find((a) => a >= this.minLabelTickSize && a * Math.abs(this.scale.factor) >= minPxDist);
+    }
+    getTickSizes() {
+        return this.tickSizes;
+    }
+    calculateTicks() {
+        let dist = this.minLabelDistance / Math.abs(this.scale.factor);
+        let unit = Math.pow(10, Math.floor(Math.log10(dist)));
+        let bestLabelDistance = Infinity;
+        let bestTicks = [];
+        let bestScale = this.scale;
+        for (let i = 0; i < this.tickDivisions.length; i++) {
+            let divs = this.tickDivisions[i];
+            let tickSizes = divs.filter((ts) => ts >= this.minTickStep).map((ts) => ts * unit);
+            let scale = this.getScale(tickSizes);
+            tickSizes.forEach((size, level) => {
+                let labelDistance = size * Math.abs(scale.factor);
+                if (labelDistance >= this.minLabelDistance && labelDistance < bestLabelDistance) {
+                    bestScale = scale;
+                    bestTicks = tickSizes;
+                    bestLabelDistance = labelDistance;
+                }
+            });
+        }
+        this.scale = bestScale;
+        this.tickSizes = bestTicks.filter((ts) => ts >= this.minTickStep && ts * Math.abs(bestScale.factor) >= this.minTickDistance);
+        if (this.tickSizes.length > 0) {
+            let max = this.tickSizes[this.tickSizes.length - 1];
+            this.tickSizes.push(2 * max);
+            this.tickSizes.push(5 * max);
+            this.tickSizes.push(10 * max);
+            let min = this.tickSizes[0];
+            let minDist = min * Math.abs(bestScale.factor);
+            if (min / 10 >= this.minTickStep && minDist / 10 >= this.minTickDistance)
+                this.tickSizes.splice(0, 0, min / 10);
+            else if (min / 5 >= this.minTickStep && minDist / 5 >= this.minTickDistance)
+                this.tickSizes.splice(0, 0, min / 5);
+            else if (min / 2 >= this.minTickStep && minDist / 2 >= this.minTickDistance)
+                this.tickSizes.splice(0, 0, min / 2);
+        }
+    }
+    getTicks(tickSizes) {
+        return tickSizes.map((size) => {
+            let start = Math.ceil((this.scale.min - this.scale.minPadding) / size);
+            let end = Math.floor((this.scale.max + this.scale.maxPadding) / size);
+            let result = [];
+            for (let i = start; i <= end; i++)
+                result.push(i * size + 0);
+            return result;
+        });
+    }
+    mapGridlines() {
+        let size = this.tickSizes[0];
+        let start = Math.ceil((this.scale.min - this.scale.minPadding) / size);
+        let end = Math.floor((this.scale.max + this.scale.maxPadding) / size);
+        let result = [];
+        for (let i = start; i <= end; i++)
+            result.push(this.map(i * size));
+        return result;
+    }
+    book() {
+        Console.warn("NumericAxis does not support the autoSize flag for column and bar graphs.");
+    }
+}

package/build/charts/axis/Stack.d.ts

@@ -0,0 +1,16 @@
+export declare class Stack {
+    stacks: Record<string, {
+        total: number;
+        min: number;
+        max: number;
+    }>;
+    values: Record<string, number>;
+    normalized: boolean;
+    invalid: Record<string, boolean>;
+    info?: any[];
+    constructor();
+    reset(): void;
+    acknowledge(ordinal: string, value: number | null): void;
+    measure(normalized: boolean): [number, number];
+    stack(ordinal: string, value: number | null): number | null;
+}