cx 26.0.1 → 26.0.3

package/build/charts/helpers/MinMaxFinder.d.ts

@@ -0,0 +1,36 @@
+import { PointReducer, PointReducerConfig, PointReducerInstance, PointReducerAccumulator } from "./PointReducer";
+import { Bind, StructuredProp } from "../../ui/Prop";
+import { AccessorChain } from "../../data/createAccessorModelProxy";
+export interface MinMaxAccumulator extends PointReducerAccumulator {
+    params: any;
+    min: {
+        x: any;
+        y: any;
+        p?: any;
+    };
+    max: {
+        x: any;
+        y: any;
+        p?: any;
+    };
+}
+export interface MinMaxFinderConfig extends PointReducerConfig {
+    /** A binding used to receive the x value of the point with the minimum value */
+    minX?: Bind | AccessorChain<number>;
+    /** A binding used to receive the y value of the point with the minimum value */
+    minY?: Bind | AccessorChain<number>;
+    /** A binding used to receive the x value of the point with the maximum value */
+    maxX?: Bind | AccessorChain<number>;
+    /** A binding used to receive the y value of the point with the maximum value */
+    maxY?: Bind | AccessorChain<number>;
+    /** An object used for filtering data points. Available as accumulator.params inside the onMap function. */
+    params?: StructuredProp;
+}
+/** Find minimum and maximum points of a point series */
+export declare class MinMaxFinder extends PointReducer<MinMaxAccumulator> {
+    constructor(config?: MinMaxFinderConfig);
+    declareData(...args: any[]): void;
+    onInitAccumulator: (acc: MinMaxAccumulator, { data }: PointReducerInstance<MinMaxAccumulator>) => void;
+    onMap: (acc: MinMaxAccumulator, x: any, y: any, name: string, p: any) => void;
+    onReduce: (acc: MinMaxAccumulator, instance: PointReducerInstance<MinMaxAccumulator>) => void;
+}

package/build/charts/helpers/MinMaxFinder.js

@@ -0,0 +1,37 @@
+import { PointReducer } from "./PointReducer";
+/** Find minimum and maximum points of a point series */
+export class MinMaxFinder extends PointReducer {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            minX: undefined,
+            minY: undefined,
+            maxX: undefined,
+            maxY: undefined,
+            params: {
+                structured: true,
+            },
+        });
+    }
+    onInitAccumulator = (acc, { data }) => {
+        acc.params = data.params;
+        acc.min = { x: null, y: null };
+        acc.max = { x: null, y: null };
+    };
+    onMap = (acc, x, y, name, p) => {
+        if (y != null && (acc.max.y == null || acc.max.y < y))
+            acc.max = { x, y, p };
+        if (y != null && (acc.min.y == null || acc.min.y > y))
+            acc.min = { x, y, p };
+    };
+    onReduce = (acc, instance) => {
+        instance.set("minX", acc.min.x);
+        instance.set("minY", acc.min.y);
+        instance.set("minRecord", acc.min.p);
+        instance.set("maxX", acc.max.x);
+        instance.set("maxY", acc.max.y);
+        instance.set("maxRecord", acc.max.p);
+    };
+}

package/build/charts/helpers/PointReducer.d.ts

@@ -0,0 +1,41 @@
+import { PureContainerBase, PureContainerConfig } from "../../ui/PureContainer";
+import { Instance } from "../../ui/Instance";
+import { RenderingContext } from "../../ui/RenderingContext";
+import { DataRecord, StructuredProp } from "../../ui/Prop";
+export type PointReducerFunction = (x: any, y: any, name: string, data: any, array?: any[], index?: number) => void;
+export interface PointReducerAccumulator {
+    [key: string]: any;
+}
+export interface PointReducerInstance<TAccumulator extends PointReducerAccumulator = PointReducerAccumulator> extends Instance {
+    resetAccumulator: () => void;
+    pointFilter?: (x: any, y: any, name: string, data: any, array?: any[], index?: number) => boolean;
+    accumulator?: TAccumulator;
+    parentPointTracker?: PointReducerFunction;
+    pointReducer?: PointReducerFunction;
+    write?: () => void;
+}
+export interface PointReducerConfig extends PureContainerConfig {
+    /** A callback function used to initialize the accumulator. */
+    onInitAccumulator?: string | ((accumulator: DataRecord, instance?: Instance) => void);
+    /** A callback function used to collect information about all data points. */
+    onMap?: string | ((accumulator: DataRecord, x?: any, y?: any, name?: string, data?: any, array?: any[], index?: number) => void);
+    /** A callback function used to process accumulated information and write results. */
+    onReduce?: string | ((accumulator: DataRecord, instance?: Instance) => void);
+    /** Parameters that trigger filter predicate re-creation. */
+    filterParams?: StructuredProp;
+    /** A callback function used to create a predicate for filtering points. */
+    onCreatePointFilter?: string | ((filterParams: any, instance: Instance) => (x: number, y: number, name: string, data: any, array?: any[], index?: number) => boolean);
+}
+export declare class PointReducer<TAccumulator extends PointReducerAccumulator = PointReducerAccumulator> extends PureContainerBase<PointReducerConfig, PointReducerInstance<TAccumulator>> {
+    onCreatePointFilter?: PointReducerConfig["onCreatePointFilter"];
+    onInitAccumulator?: (acc: TAccumulator, instance: PointReducerInstance<TAccumulator>) => void;
+    onMap?: (acc: TAccumulator, x: any, y: any, name: string, data?: any, array?: any[], index?: number) => void;
+    onReduce?: (acc: TAccumulator, instance: PointReducerInstance<TAccumulator>) => void;
+    constructor(config?: PointReducerConfig);
+    declareData(...args: any[]): void;
+    prepareData(context: RenderingContext, instance: PointReducerInstance<TAccumulator>): void;
+    explore(context: RenderingContext, instance: PointReducerInstance<TAccumulator>): void;
+    exploreCleanup(context: RenderingContext, instance: PointReducerInstance<TAccumulator>): void;
+    prepare(context: RenderingContext, instance: PointReducerInstance<TAccumulator>): void;
+    prepareCleanup(context: RenderingContext, instance: PointReducerInstance<TAccumulator>): void;
+}

package/build/charts/helpers/PointReducer.js

@@ -0,0 +1,55 @@
+import { PureContainerBase } from "../../ui/PureContainer";
+export class PointReducer extends PureContainerBase {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            filterParams: {
+                structured: true,
+            },
+        });
+    }
+    prepareData(context, instance) {
+        super.prepareData(context, instance);
+        instance.resetAccumulator = () => {
+            let accumulator = {};
+            if (this.onInitAccumulator) {
+                instance.invoke("onInitAccumulator", accumulator, instance);
+                instance.accumulator = accumulator;
+            }
+        };
+        if (this.onCreatePointFilter)
+            instance.pointFilter = instance.invoke("onCreatePointFilter", instance.data.filterParams, instance);
+    }
+    explore(context, instance) {
+        instance.resetAccumulator();
+        let parentPointReducer = context.pointReducer;
+        instance.parentPointTracker = parentPointReducer;
+        let pointFilter = instance.pointFilter;
+        let accumulator = instance.accumulator;
+        let onMap = this.onMap && instance.getCallback("onMap");
+        instance.pointReducer = (x, y, name, data, array, index) => {
+            if (!pointFilter || pointFilter(x, y, name, data, array, index))
+                onMap?.(accumulator, x, y, name, data, array, index);
+            if (parentPointReducer)
+                parentPointReducer(x, y, name, data, array, index);
+        };
+        instance.write = () => {
+            if (this.onReduce)
+                instance.invoke("onReduce", accumulator, instance);
+        };
+        context.push("pointReducer", instance.pointReducer);
+        super.explore(context, instance);
+    }
+    exploreCleanup(context, instance) {
+        context.pop("pointReducer");
+    }
+    prepare(context, instance) {
+        context.push("pointReducer", instance.pointReducer);
+    }
+    prepareCleanup(context, instance) {
+        context.pop("pointReducer");
+        instance.write?.();
+    }
+}

package/build/charts/helpers/SnapPointFinder.d.ts

@@ -0,0 +1,58 @@
+import { PointReducer, PointReducerConfig, PointReducerInstance, PointReducerAccumulator } from "./PointReducer";
+import { RenderingContext } from "../../ui/RenderingContext";
+import { NumberProp, Bind, Prop, DataRecord } from "../../ui/Prop";
+import { AccessorChain } from "../../data/createAccessorModelProxy";
+export interface SnapAccumulator extends PointReducerAccumulator {
+    cursor: {
+        x: number | null;
+        y: number | null;
+        mapped: boolean;
+        mappedX?: number | null;
+        mappedY?: number | null;
+    };
+    dist: number;
+    snapX: any;
+    snapY: any;
+    snapRecord?: any;
+    xAxis: any;
+    yAxis: any;
+}
+export interface SnapPointFinderInstance extends PointReducerInstance<SnapAccumulator> {
+    xAxis?: any;
+    yAxis?: any;
+}
+export interface SnapPointFinderConfig extends PointReducerConfig {
+    /** Cursor X value. */
+    cursorX?: NumberProp;
+    /** Cursor Y value */
+    cursorY?: NumberProp;
+    /** A binding used to receive the x value of the nearest point.*/
+    snapX?: Bind | AccessorChain<number> | AccessorChain<string>;
+    /** A binding used to receive the y value of the nearest point. */
+    snapY?: Bind | AccessorChain<number> | AccessorChain<string>;
+    /** A binding used to receive the record prop */
+    snapRecord?: Prop<DataRecord>;
+    /** Maximum distance between cursor and the snap point. Default value is 50. Adjust accordingly for large distances, e.g. set to Infinity when using TimeAxis */
+    maxDistance?: number;
+    /** A function used to convert x values into numeric format. Commonly used with dates. */
+    convertX?: (value: number | string) => number;
+    /** A function used to convert y values into numeric format. Commonly used with dates. */
+    convertY?: (value: number | string) => number;
+    /** Name of the x-axis. Default is 'x'. */
+    xAxis?: string;
+    /** Name of the y-axis. Default is 'y'. */
+    yAxis?: string;
+}
+export declare class SnapPointFinder extends PointReducer<SnapAccumulator> {
+    maxDistance: number;
+    convertX: (value: any) => number;
+    convertY: (value: any) => number;
+    xAxis: string;
+    yAxis: string;
+    constructor(config?: SnapPointFinderConfig);
+    declareData(...args: any[]): void;
+    explore(context: RenderingContext, instance: SnapPointFinderInstance): void;
+    onInitAccumulator: (acc: SnapAccumulator, { data, xAxis, yAxis }: SnapPointFinderInstance) => void;
+    onMap: (acc: SnapAccumulator, x: any, y: any, name: string, p: any) => void;
+    onReduce: (acc: SnapAccumulator, instance: PointReducerInstance<SnapAccumulator>) => void;
+}

package/build/charts/helpers/SnapPointFinder.js

@@ -0,0 +1,65 @@
+import { PointReducer } from "./PointReducer";
+export class SnapPointFinder extends PointReducer {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            cursorX: undefined,
+            cursorY: undefined,
+            snapX: undefined,
+            snapY: undefined,
+            snapRecord: undefined,
+            maxDistance: undefined,
+        });
+    }
+    explore(context, instance) {
+        instance.xAxis = context.axes?.[this.xAxis];
+        instance.yAxis = context.axes?.[this.yAxis];
+        super.explore(context, instance);
+    }
+    onInitAccumulator = (acc, { data, xAxis, yAxis }) => {
+        const d = data;
+        acc.cursor = {
+            x: d.cursorX,
+            y: d.cursorY,
+            mapped: false,
+        };
+        acc.dist = d.maxDistance > 0 ? Math.pow(d.maxDistance, 2) : Number.POSITIVE_INFINITY;
+        acc.snapX = null;
+        acc.snapY = null;
+        acc.xAxis = xAxis;
+        acc.yAxis = yAxis;
+    };
+    onMap = (acc, x, y, name, p) => {
+        let { xAxis, yAxis, cursor } = acc;
+        if (!cursor.mapped) {
+            cursor.mappedX = cursor.x != null ? xAxis?.map(this.convertX(cursor.x)) : null;
+            cursor.mappedY = cursor.y != null ? yAxis?.map(this.convertY(cursor.y)) : null;
+            cursor.mapped = true;
+        }
+        let d = null;
+        let cx = x != null ? xAxis?.map(this.convertX(x)) : null;
+        let cy = y != null ? yAxis?.map(this.convertY(y)) : null;
+        if (cursor.mappedX != null && cx != null)
+            d = (d || 0) + Math.pow(Math.abs(cx - cursor.mappedX), 2);
+        if (cursor.mappedY != null && cy != null)
+            d = (d || 0) + Math.pow(Math.abs(cy - cursor.mappedY), 2);
+        if (d != null && d < acc.dist) {
+            acc.dist = d;
+            acc.snapX = x;
+            acc.snapY = y;
+            acc.snapRecord = p;
+        }
+    };
+    onReduce = (acc, instance) => {
+        instance.set("snapX", acc.snapX);
+        instance.set("snapY", acc.snapY);
+        instance.set("snapRecord", acc.snapRecord);
+    };
+}
+SnapPointFinder.prototype.maxDistance = 50;
+SnapPointFinder.prototype.convertX = (x) => x;
+SnapPointFinder.prototype.convertY = (y) => y;
+SnapPointFinder.prototype.xAxis = "x";
+SnapPointFinder.prototype.yAxis = "y";

package/build/charts/helpers/ValueAtFinder.d.ts

@@ -0,0 +1,33 @@
+import { PointReducer, PointReducerConfig, PointReducerInstance, PointReducerAccumulator } from "./PointReducer";
+import { NumberProp, StringProp, Bind } from "../../ui/Prop";
+import { AccessorChain } from "../../data/createAccessorModelProxy";
+export interface ValueAtAccumulator extends PointReducerAccumulator {
+    at: number;
+    left?: {
+        x: number;
+        y: number;
+        d: number;
+    };
+    right?: {
+        x: number;
+        y: number;
+        d: number;
+    };
+}
+export interface ValueAtFinderConfig extends PointReducerConfig {
+    /** X axis probe value. */
+    at?: NumberProp | StringProp;
+    /** A binding used to receive the measured y axis value */
+    value?: Bind | AccessorChain<number>;
+    /** A function used to convert x values into numeric format. Commonly used with dates. */
+    convert?: (value: number | string) => number;
+}
+/** Calculate value at a given point on the graph */
+export declare class ValueAtFinder extends PointReducer<ValueAtAccumulator> {
+    convert: (value: any) => number;
+    constructor(config?: ValueAtFinderConfig);
+    declareData(...args: any[]): void;
+    onInitAccumulator: (acc: ValueAtAccumulator, { data }: PointReducerInstance<ValueAtAccumulator>) => void;
+    onMap: (acc: ValueAtAccumulator, x: any, y: any, name: string) => void;
+    onReduce: (acc: ValueAtAccumulator, instance: PointReducerInstance<ValueAtAccumulator>) => void;
+}

package/build/charts/helpers/ValueAtFinder.js

@@ -0,0 +1,46 @@
+import { PointReducer } from "./PointReducer";
+/** Calculate value at a given point on the graph */
+export class ValueAtFinder extends PointReducer {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            at: undefined,
+            value: undefined,
+        });
+    }
+    onInitAccumulator = (acc, { data }) => {
+        acc.at = this.convert(data.at);
+    };
+    onMap = (acc, x, y, name) => {
+        let cx = this.convert(x);
+        let d = cx - acc.at;
+        if (d <= 0 && (!acc.left || acc.left.d < d)) {
+            acc.left = {
+                x: cx,
+                y,
+                d,
+            };
+        }
+        if (d >= 0 && (!acc.right || acc.right.d > d)) {
+            acc.right = {
+                x: cx,
+                y,
+                d,
+            };
+        }
+    };
+    onReduce = (acc, instance) => {
+        let y = null;
+        if (acc.left && acc.right) {
+            if (acc.left.x == acc.right.x)
+                y = acc.left.y;
+            else if (acc.left.y != null && acc.right.y != null) {
+                y = acc.left.y + ((acc.right.y - acc.left.y) * (acc.at - acc.left.x)) / (acc.right.x - acc.left.x);
+            }
+        }
+        instance.set("value", y);
+    };
+}
+ValueAtFinder.prototype.convert = (x) => x;

package/build/charts/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./PointReducer";
+export * from "./MinMaxFinder";
+export * from "./SnapPointFinder";
+export * from "./ValueAtFinder";

package/build/charts/helpers/index.js

@@ -0,0 +1,4 @@
+export * from "./PointReducer";
+export * from "./MinMaxFinder";
+export * from "./SnapPointFinder";
+export * from "./ValueAtFinder";

package/build/charts/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./Chart";
+export * from "./PieChart";
+export * from "./Pie";
+export * from "./PieLabel";
+export * from "./PieLabelsContainer";
+export * from "./Column";
+export * from "./Bar";
+export * from "./Legend";
+export * from "./LegendEntry";
+export * from "./ColorMap";
+export * from "./Marker";
+export * from "./MarkerLine";
+export * from "./Range";
+export * from "./Gridlines";
+export * from "./Swimlanes";
+export * from "./Swimlane";
+export * from "./RangeMarker";
+export * from "./LineGraph";
+export * from "./ColumnGraph";
+export * from "./BarGraph";
+export * from "./ScatterGraph";
+export * from "./BubbleGraph";
+export * from "./MouseTracker";
+export * from "./shapes";
+export * from "./axis/index";
+export * from "./helpers/index";

package/build/charts/index.js

@@ -0,0 +1,26 @@
+export * from "./Chart";
+export * from "./PieChart";
+export * from "./Pie";
+export * from "./PieLabel";
+export * from "./PieLabelsContainer";
+export * from "./Column";
+export * from "./Bar";
+export * from "./Legend";
+export * from "./LegendEntry";
+export * from "./ColorMap";
+export * from "./Marker";
+export * from "./MarkerLine";
+export * from "./Range";
+export * from "./Gridlines";
+export * from "./Swimlanes";
+export * from "./Swimlane";
+export * from "./RangeMarker";
+export * from "./LineGraph";
+export * from "./ColumnGraph";
+export * from "./BarGraph";
+export * from "./ScatterGraph";
+export * from "./BubbleGraph";
+export * from "./MouseTracker";
+export * from "./shapes";
+export * from "./axis/index";
+export * from "./helpers/index";

package/build/charts/shapes.d.ts

@@ -0,0 +1,13 @@
+/** @jsxImportSource react */
+import { Config } from "../ui/Prop";
+export type ShapeRender = (cx: number, cy: number, size: number, props?: Config, options?: Config) => React.ReactElement;
+export declare function registerShape(name: string, callback: ShapeRender): void;
+export declare function getShape(shapeName: string): ShapeRender;
+export declare function getAvailableShapes(): string[];
+export declare function circle(cx: number, cy: number, size: number, props?: Config, options?: Config): React.ReactElement;
+export declare function square(cx: number, cy: number, size: number, props?: Config, options?: Config): React.ReactElement;
+export declare function bar(cx: number, cy: number, size: number, props?: Config, options?: Config): React.ReactElement;
+export declare function column(cx: number, cy: number, size: number, props?: Config, options?: Config): React.ReactElement;
+export declare function line(cx: number, cy: number, size: number, props?: Config, options?: Config): React.ReactElement;
+export declare function vline(cx: number, cy: number, size: number, props?: Config, options?: Config): React.ReactElement;
+export declare function triangle(cx: number, cy: number, size: number, props?: Config, options?: Config): React.ReactElement;

package/build/charts/shapes.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { debug } from "../util/Debug";
+var shapes = {};
+var warnings = {};
+export function registerShape(name, callback) {
+    shapes[name] = callback;
+}
+export function getShape(shapeName) {
+    if (shapes[shapeName])
+        return shapes[shapeName];
+    if (!warnings[shapeName]) {
+        warnings[shapeName] = true;
+        debug(`Unknown shape '${shapeName}'. Using square instead.`);
+    }
+    return shapes["square"];
+}
+export function getAvailableShapes() {
+    return Object.keys(shapes);
+}
+export function circle(cx, cy, size, props, options) {
+    return _jsx("circle", { ...props, cx: cx, cy: cy, r: size / 2 });
+}
+registerShape("circle", circle);
+export function square(cx, cy, size, props, options) {
+    size *= 0.9;
+    return _jsx("rect", { ...props, x: cx - size / 2, y: cy - size / 2, width: size, height: size });
+}
+registerShape("square", square);
+registerShape("rect", square);
+export function bar(cx, cy, size, props, options) {
+    size *= 0.9;
+    return _jsx("rect", { ...props, x: cx - size / 2, y: cy - size / 4, width: size, height: size / 2 });
+}
+registerShape("bar", bar);
+export function column(cx, cy, size, props, options) {
+    size *= 0.9;
+    return _jsx("rect", { ...props, x: cx - size / 4, y: cy - size / 2, width: size / 2, height: size });
+}
+registerShape("column", column);
+export function line(cx, cy, size, props, options) {
+    size *= 0.9;
+    return _jsx("line", { ...props, x1: cx - size / 2, y1: cy, x2: cx + size / 2, y2: cy });
+}
+registerShape("line", line);
+registerShape("hline", line);
+export function vline(cx, cy, size, props, options) {
+    size *= 0.9;
+    return _jsx("line", { ...props, x1: cx, y1: cy - size / 2, x2: cx, y2: cy + size / 2 });
+}
+registerShape("vline", vline);
+export function triangle(cx, cy, size, props, options) {
+    size *= 1.29;
+    var d = "";
+    var cos = Math.cos(Math.PI / 6);
+    var sin = Math.sin(Math.PI / 6);
+    d += `M ${cx} ${cy - size / 2} `;
+    d += `L ${cx + (cos * size) / 2} ${cy + (sin * size) / 2} `;
+    d += `L ${cx - (cos * size) / 2} ${cy + (sin * size) / 2} `;
+    d += `Z`;
+    return _jsx("path", { ...props, d: d });
+}
+registerShape("triangle", triangle);

package/build/data/AggregateFunction.d.ts

@@ -0,0 +1,60 @@
+export declare class AggregateFunction {
+    static sum(): Sum;
+    static avg(): Avg;
+    static count(): Count;
+    static distinct(): Distinct;
+    static min(): Min;
+    static max(): Max;
+    static last(): LastValue;
+}
+declare class Sum {
+    result: number;
+    empty: boolean;
+    invalid?: boolean;
+    process(value: number): void;
+    getResult(): number | null;
+}
+declare class Avg {
+    result: number;
+    count: number;
+    empty: boolean;
+    invalid?: boolean;
+    process(value: number, count?: number): void;
+    getResult(): number | null;
+}
+declare class Count {
+    result: number;
+    process(value: any): void;
+    getResult(): number;
+}
+declare class Distinct {
+    values: {
+        [key: string]: boolean;
+    };
+    empty: boolean;
+    result: number;
+    invalid?: boolean;
+    constructor();
+    process(value: any): void;
+    getResult(): number | null;
+}
+declare class Max {
+    result: number;
+    empty: boolean;
+    invalid?: boolean;
+    process(value: number): void;
+    getResult(): number | null;
+}
+declare class Min {
+    result: number;
+    empty: boolean;
+    invalid?: boolean;
+    process(value: number): void;
+    getResult(): number | null;
+}
+declare class LastValue {
+    result: any;
+    process(value: any): void;
+    getResult(): any;
+}
+export {};