cx 26.0.1 → 26.0.3

package/build/charts/Bar.d.ts

@@ -0,0 +1,29 @@
+import { ColumnBarBase, ColumnBarBaseConfig, ColumnBarBaseInstance } from "./ColumnBarBase";
+import { Rect } from "../svg/util/Rect";
+import { RenderingContext } from "../ui/RenderingContext";
+import { NumberProp, BooleanProp } from "../ui/Prop";
+export interface BarConfig extends ColumnBarBaseConfig {
+    /** Base value. Default value is `0`. */
+    x0?: NumberProp;
+    /** Size (height) of the bar in axis units. */
+    size?: NumberProp;
+    /** Set to true to auto calculate size and offset. Available only if the y axis is a category axis. */
+    autoSize?: BooleanProp;
+    /** Alias for size. */
+    height?: number;
+    /** Hide the base of the bar (x0). */
+    hiddenBase?: boolean;
+}
+export declare class Bar extends ColumnBarBase {
+    x0: number;
+    size: number;
+    autoSize: boolean;
+    height: number;
+    hiddenBase: boolean;
+    constructor(config: BarConfig);
+    init(): void;
+    declareData(...args: any[]): any;
+    checkValid(data: any): boolean;
+    explore(context: RenderingContext, instance: ColumnBarBaseInstance): void;
+    calculateRect(instance: ColumnBarBaseInstance): Rect;
+}

package/build/charts/Bar.js

@@ -0,0 +1,74 @@
+import { Widget } from "../ui/Widget";
+import { ColumnBarBase } from "./ColumnBarBase";
+import { Rect } from "../svg/util/Rect";
+import { isDefined } from "../util/isDefined";
+export class Bar extends ColumnBarBase {
+    constructor(config) {
+        super(config);
+    }
+    init() {
+        if (isDefined(this.height))
+            this.size = this.height;
+        super.init();
+    }
+    declareData(...args) {
+        return super.declareData({
+            x0: undefined,
+            size: undefined,
+            autoSize: undefined,
+        }, ...args);
+    }
+    checkValid(data) {
+        return data.y != null && data.x != null && data.x0 != null;
+    }
+    explore(context, instance) {
+        let { data, xAxis, yAxis } = instance;
+        instance.colorMap = data.colorMap && context.getColorMap && context.getColorMap(data.colorMap);
+        if (instance.colorMap && data.colorName)
+            instance.colorMap.acknowledge(data.colorName);
+        if (!data.valid)
+            return;
+        if (data.active) {
+            yAxis.acknowledge(data.y, data.size, data.offset);
+            if (data.autoSize)
+                yAxis.book(data.y, data.stacked ? data.stack : data.name);
+            if (data.stacked) {
+                xAxis.stacknowledge(data.stack, data.y, data.x0);
+                xAxis.stacknowledge(data.stack, data.y, data.x);
+            }
+            else {
+                if (!this.hiddenBase)
+                    xAxis.acknowledge(data.x0);
+                xAxis.acknowledge(data.x);
+            }
+            super.explore(context, instance);
+        }
+    }
+    calculateRect(instance) {
+        let { data } = instance;
+        var { offset, size } = data;
+        if (data.autoSize) {
+            var [index, count] = instance.yAxis.locate(data.y, data.stacked ? data.stack : data.name);
+            offset = (size / count) * (index - count / 2 + 0.5);
+            size = size / count;
+        }
+        var x1 = data.stacked ? instance.xAxis.stack(data.stack, data.y, data.x0) : instance.xAxis.map(data.x0);
+        var x2 = data.stacked ? instance.xAxis.stack(data.stack, data.y, data.x) : instance.xAxis.map(data.x);
+        var y1 = instance.yAxis.map(data.y, offset - size / 2);
+        var y2 = instance.yAxis.map(data.y, offset + size / 2);
+        var bounds = new Rect({
+            l: Math.min(x1, x2),
+            r: Math.max(x1, x2),
+            t: Math.min(y1, y2),
+            b: Math.max(y1, y2),
+        });
+        return bounds;
+    }
+}
+Bar.prototype.baseClass = "bar";
+Bar.prototype.x0 = 0;
+Bar.prototype.size = 1;
+Bar.prototype.autoSize = false;
+Bar.prototype.legendShape = "bar";
+Bar.prototype.hiddenBase = false;
+Widget.alias("bar", Bar);

package/build/charts/BarGraph.d.ts

@@ -0,0 +1,29 @@
+/** @jsxImportSource react */
+import { ColumnBarGraphBase, ColumnBarGraphBaseConfig, ColumnBarGraphBaseInstance } from "./ColumnBarGraphBase";
+import { TooltipParentInstance } from "../widgets/overlay/tooltip-ops";
+import { RenderingContext } from "../ui/RenderingContext";
+import { NumberProp } from "../ui/Prop";
+export interface BarGraphConfig extends ColumnBarGraphBaseConfig {
+    /**
+     * Name of the property which holds the base value.
+     * Default value is `false`, which means x0 value is not read from the data array.
+     */
+    x0Field?: string | false;
+    /** Bar base value. Default value is `0`. */
+    x0?: NumberProp;
+    /** Hide the base of the bar (x0). */
+    hiddenBase?: boolean;
+    /** Tooltip configuration. */
+    tooltip?: any;
+}
+export interface BarGraphInstance extends ColumnBarGraphBaseInstance, TooltipParentInstance {
+}
+export declare class BarGraph extends ColumnBarGraphBase {
+    x0Field: string | false;
+    x0: number;
+    hiddenBase: boolean;
+    tooltip: any;
+    constructor(config: BarGraphConfig);
+    explore(context: RenderingContext, instance: BarGraphInstance): void;
+    renderGraph(context: RenderingContext, instance: BarGraphInstance): React.ReactNode;
+}

package/build/charts/BarGraph.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** @jsxImportSource react */
+import { Widget } from "../ui/Widget";
+import { ColumnBarGraphBase } from "./ColumnBarGraphBase";
+import { tooltipMouseMove, tooltipMouseLeave } from "../widgets/overlay/tooltip-ops";
+import { isArray } from "../util/isArray";
+export class BarGraph extends ColumnBarGraphBase {
+    constructor(config) {
+        super(config);
+    }
+    explore(context, instance) {
+        super.explore(context, instance);
+        let { data, yAxis, xAxis } = instance;
+        if (isArray(data.data)) {
+            data.data.forEach((p) => {
+                var x0 = this.x0Field ? p[this.x0Field] : data.x0;
+                var y = p[this.yField];
+                var x = p[this.xField];
+                yAxis.acknowledge(y, data.size, data.offset);
+                if (data.autoSize)
+                    yAxis.book(y, data.stacked ? data.stack : data.name);
+                if (data.stacked) {
+                    xAxis.stacknowledge(data.stack, y, x0);
+                    xAxis.stacknowledge(data.stack, y, x);
+                }
+                else {
+                    if (!this.hiddenBase)
+                        xAxis.acknowledge(x0);
+                    xAxis.acknowledge(x);
+                }
+            });
+        }
+    }
+    renderGraph(context, instance) {
+        var { data, yAxis, xAxis, store } = instance;
+        if (!isArray(data.data))
+            return false;
+        var isSelected = this.selection.getIsSelectedDelegate(store);
+        return data.data.map((p, i) => {
+            var { offset, size } = data;
+            var x0 = this.x0Field ? p[this.x0Field] : data.x0;
+            var y = p[this.yField];
+            var x = p[this.xField];
+            if (data.autoSize) {
+                var [index, count] = instance.yAxis.locate(y, data.stacked ? data.stack : data.name);
+                offset = (size / count) * (index - count / 2 + 0.5);
+                size = size / count;
+            }
+            var y1 = yAxis.map(y, offset - size / 2);
+            var y2 = yAxis.map(y, offset + size / 2);
+            var x1 = data.stacked ? xAxis.stack(data.stack, y, x0) : xAxis.map(x0);
+            var x2 = data.stacked ? xAxis.stack(data.stack, y, x) : xAxis.map(x);
+            var color = this.colorIndexField ? p[this.colorIndexField] : data.colorIndex;
+            var state = {
+                selected: isSelected(p, i),
+                selectable: !this.selection.isDummy,
+                [`color-${color}`]: color != null,
+            };
+            let mmove, mleave;
+            if (this.tooltip) {
+                mmove = (e) => tooltipMouseMove(e, instance, this.tooltip, {
+                    target: e.target.parent,
+                    data: {
+                        $record: p,
+                    },
+                });
+                mleave = (e) => tooltipMouseLeave(e, instance, this.tooltip, {
+                    target: e.target.parent,
+                    data: {
+                        $record: p,
+                    },
+                });
+            }
+            return (_jsx("rect", { className: this.CSS.element(this.baseClass, "bar", state), onClick: (e) => {
+                    this.handleClick(e, instance, p, i);
+                }, x: Math.min(x1, x2), y: Math.min(y1, y2), width: Math.abs(x2 - x1), height: Math.abs(y2 - y1), style: data.style, onMouseMove: mmove, onMouseLeave: mleave, rx: data.borderRadius }, i));
+        });
+    }
+}
+BarGraph.prototype.baseClass = "bargraph";
+BarGraph.prototype.x0Field = false;
+BarGraph.prototype.x0 = 0;
+BarGraph.prototype.legendShape = "bar";
+BarGraph.prototype.hiddenBase = false;
+BarGraph.prototype.borderRadius = 0;
+Widget.alias("bargraph", BarGraph);

package/build/charts/BubbleGraph.d.ts

@@ -0,0 +1,54 @@
+/** @jsxImportSource react */
+import { Widget, WidgetConfig } from "../ui/Widget";
+import { Selection, SimpleSelection } from "../ui/selection/Selection";
+import type { KeySelection } from "../ui/selection/KeySelection";
+import type { PropertySelection } from "../ui/selection/PropertySelection";
+import { Instance } from "../ui/Instance";
+import { CxChild } from "../ui/RenderingContext";
+import { Prop, StyleProp, DataRecord } from "../ui/Prop";
+import { Create } from "../util/Component";
+import type { ChartRenderingContext } from "./Chart";
+export interface BubbleGraphConfig extends WidgetConfig {
+    /** Data array for the bubbles. */
+    data?: Prop<DataRecord[]>;
+    /** Default bubble radius. Default is 10. */
+    bubbleRadius?: number;
+    /** Style object applied to all bubbles. */
+    bubbleStyle?: StyleProp;
+    /** Name of the x-axis. Default is 'x'. */
+    xAxis?: string;
+    /** Name of the y-axis. Default is 'y'. */
+    yAxis?: string;
+    /** Name of the field in data objects that contains x values. Default is 'x'. */
+    xField?: string;
+    /** Name of the field in data objects that contains y values. Default is 'y'. */
+    yField?: string;
+    /** Name of the field in data objects that contains radius values. Default is 'r'. */
+    rField?: string;
+    /** Selection configuration. */
+    selection?: Create<typeof Selection> | Create<typeof KeySelection> | Create<typeof PropertySelection> | Create<typeof SimpleSelection>;
+}
+export interface BubbleGraphInstance extends Instance {
+    axes: {
+        [key: string]: any;
+    };
+}
+export declare class BubbleGraph extends Widget<BubbleGraphConfig> {
+    baseClass: string;
+    xAxis: string;
+    yAxis: string;
+    xField: string;
+    yField: string;
+    rField: string;
+    bubbleRadius: number;
+    selection: Selection;
+    data?: Prop<DataRecord[]>;
+    constructor(config?: BubbleGraphConfig);
+    declareData(...args: any[]): void;
+    init(): void;
+    explore(context: ChartRenderingContext, instance: BubbleGraphInstance): void;
+    prepare(context: ChartRenderingContext, instance: BubbleGraphInstance): void;
+    render(context: ChartRenderingContext, instance: BubbleGraphInstance, key: string): CxChild;
+    renderData(context: ChartRenderingContext, instance: BubbleGraphInstance): any;
+    onBubbleClick(e: React.MouseEvent, instance: BubbleGraphInstance, index: number): void;
+}

package/build/charts/BubbleGraph.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** @jsxImportSource react */
+import { Widget } from "../ui/Widget";
+import { Selection } from "../ui/selection/Selection";
+import { CSS } from "../ui/CSS";
+import { isArray } from "../util/isArray";
+export class BubbleGraph extends Widget {
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        var selection = this.selection.configureWidget(this);
+        super.declareData(...args, {
+            data: undefined,
+            bubbleRadius: undefined,
+            bubbleStyle: {
+                structured: true,
+            },
+        }, selection);
+    }
+    init() {
+        this.selection = Selection.create(this.selection, {
+            records: this.data,
+        });
+        super.init();
+    }
+    explore(context, instance) {
+        instance.axes = context.axes;
+        super.explore(context, instance);
+        var { data } = instance;
+        const d = data;
+        if (isArray(d.data)) {
+            d.data.forEach((p) => {
+                instance.axes[this.xAxis].acknowledge(p[this.xField]);
+                instance.axes[this.yAxis].acknowledge(p[this.yField]);
+            });
+        }
+    }
+    prepare(context, instance) {
+        super.prepare?.(context, instance);
+        if (instance.axes[this.xAxis].shouldUpdate || instance.axes[this.yAxis].shouldUpdate)
+            instance.markShouldUpdate(context);
+    }
+    render(context, instance, key) {
+        var { data } = instance;
+        return (_jsx("g", { className: data.classNames, children: this.renderData(context, instance) }, key));
+    }
+    renderData(context, instance) {
+        var { data, axes, store } = instance;
+        const d = data;
+        var xAxis = axes[this.xAxis];
+        var yAxis = axes[this.yAxis];
+        return (isArray(d.data) &&
+            d.data.map((p, i) => {
+                var selected = this.selection && this.selection.isSelected(store, p, i);
+                var classes = CSS.element(this.baseClass, "bubble", {
+                    selected: selected,
+                });
+                return (_jsx("circle", { className: classes, cx: xAxis.map(p[this.xField]), cy: yAxis.map(p[this.yField]), r: p[this.rField] || d.bubbleRadius, style: p.style || d.bubbleStyle, onClick: (e) => {
+                        this.onBubbleClick(e, instance, i);
+                    } }, i));
+            }));
+    }
+    onBubbleClick(e, instance, index) {
+        const { data, store } = instance;
+        const d = data;
+        var bubble = d.data[index];
+        this.selection.select(store, bubble, index, {
+            toggle: e.ctrlKey,
+        });
+    }
+}
+BubbleGraph.prototype.baseClass = "bubblegraph";
+BubbleGraph.prototype.xAxis = "x";
+BubbleGraph.prototype.yAxis = "y";
+BubbleGraph.prototype.xField = "x";
+BubbleGraph.prototype.yField = "y";
+BubbleGraph.prototype.rField = "r";
+BubbleGraph.prototype.bubbleRadius = 10;
+Widget.alias("bubble-graph", BubbleGraph);

package/build/charts/Chart.d.ts

@@ -0,0 +1,31 @@
+import { BoundedObject, BoundedObjectConfig, BoundedObjectInstance, SvgRenderingContext } from "../svg/BoundedObject";
+import { Axis } from "./axis/Axis";
+import type { NumericAxis } from "./axis/NumericAxis";
+import type { CategoryAxis } from "./axis/CategoryAxis";
+import type { TimeAxis } from "./axis/TimeAxis";
+import { Create } from "../util/Component";
+/** Typed context interface for chart-related context properties */
+export interface ChartRenderingContext extends SvgRenderingContext {
+    axes?: Record<string, any>;
+}
+export interface ChartConfig extends BoundedObjectConfig {
+    /** Axis definition. Each key represent an axis, and each value hold axis configuration. */
+    axes?: Record<string, Create<typeof Axis> | Create<typeof NumericAxis> | Create<typeof CategoryAxis> | Create<typeof TimeAxis>>;
+    /** Put axes over data series. */
+    axesOnTop?: boolean;
+}
+export interface ChartInstance extends BoundedObjectInstance {
+    calculators: Record<string, any>;
+    axes: Record<string, any>;
+}
+export declare class Chart extends BoundedObject<ChartConfig, ChartInstance> {
+    axes: Record<string, any>;
+    axesOnTop: boolean;
+    constructor(config?: ChartConfig);
+    init(): void;
+    explore(context: ChartRenderingContext, instance: ChartInstance): void;
+    exploreCleanup(context: ChartRenderingContext, instance: ChartInstance): void;
+    prepare(context: ChartRenderingContext, instance: ChartInstance): void;
+    prepareCleanup(context: ChartRenderingContext, instance: ChartInstance): void;
+    render(context: ChartRenderingContext, instance: ChartInstance, key: string): any[];
+}

package/build/charts/Chart.js

@@ -0,0 +1,62 @@
+import { Widget, getContent } from "../ui/Widget";
+import { BoundedObject } from "../svg/BoundedObject";
+import { Axis } from "./axis/Axis";
+export class Chart extends BoundedObject {
+    constructor(config) {
+        super(config);
+    }
+    init() {
+        super.init();
+        if (!this.axes)
+            this.axes = {};
+        for (let axis in this.axes) {
+            this.axes[axis] = Axis.create(this.axes[axis]);
+        }
+    }
+    explore(context, instance) {
+        instance.calculators = { ...context.axes };
+        context.push("axes", instance.calculators);
+        instance.axes = {};
+        //axes need to be registered before children to be processed first
+        for (let axis in this.axes) {
+            let axisInstance = instance.getChild(context, this.axes[axis]);
+            if (axisInstance.scheduleExploreIfVisible(context)) {
+                instance.axes[axis] = axisInstance;
+                instance.calculators[axis] = this.axes[axis].report(context, axisInstance);
+            }
+        }
+        super.explore(context, instance);
+    }
+    exploreCleanup(context, instance) {
+        context.pop("axes");
+        for (let axis in instance.axes) {
+            instance.axes[axis].widget.reportData(context, instance.axes[axis]);
+        }
+    }
+    prepare(context, instance) {
+        context.push("axes", instance.calculators);
+        super.prepare(context, instance);
+    }
+    prepareCleanup(context, instance) {
+        context.pop("axes");
+        super.prepareCleanup(context, instance);
+    }
+    render(context, instance, key) {
+        let axes = [];
+        for (let k in instance.axes) {
+            axes.push(getContent(instance.axes[k].render(context, key + "-axis-" + k)));
+        }
+        let result = [];
+        if (!this.axesOnTop)
+            result.push(axes);
+        result.push(this.renderChildren(context, instance));
+        if (this.axesOnTop)
+            result.push(axes);
+        return result;
+    }
+}
+Chart.prototype.anchors = "0 1 1 0";
+Chart.prototype.styled = true;
+Chart.prototype.isPureContainer = true;
+Chart.prototype.axesOnTop = false;
+Widget.alias("chart", Chart);

package/build/charts/ColorMap.d.ts

@@ -0,0 +1,59 @@
+import { Widget, WidgetConfig } from "../ui/Widget";
+import { PureContainerBase, PureContainerConfig } from "../ui/PureContainer";
+import { Instance } from "../ui/Instance";
+import { RenderingContext } from "../ui/RenderingContext";
+import { Prop, NumberProp, DataRecord } from "../ui/Prop";
+export interface ColorMapConfig extends WidgetConfig {
+    /** A callback function used to get a cache object for storing color maps across renders. */
+    onGetCache?: string | (() => DataRecord);
+    /** An array of names to pre-register in the color map. */
+    names?: Prop<string[]>;
+    /** The step value for color indexing. If not specified, it's calculated based on the number of entries. */
+    step?: NumberProp;
+    /** The starting offset for color indexing. Default is 0. */
+    offset?: NumberProp;
+    /** The size of the color palette. Default is 16. */
+    size?: NumberProp;
+}
+export interface ColorMapInstance extends Instance {
+    colorMaps?: {
+        [key: string]: ColorIndex;
+    };
+}
+export declare class ColorMap extends Widget<ColorMapConfig> {
+    offset: number;
+    step: number | null;
+    size: number;
+    onGetCache?: ColorMapConfig["onGetCache"];
+    static Scope: typeof ColorMapScope;
+    constructor(config?: ColorMapConfig);
+    declareData(...args: any[]): void;
+    explore(context: RenderingContext, instance: Instance): void;
+    render(): null;
+}
+export interface ColorMapScopeConfig extends PureContainerConfig {
+}
+export declare class ColorMapScope extends PureContainerBase<ColorMapScopeConfig, ColorMapInstance> {
+    constructor(config?: ColorMapScopeConfig);
+    explore(context: RenderingContext, instance: ColorMapInstance): void;
+    exploreCleanup(context: RenderingContext, instance: ColorMapInstance): void;
+    prepare(context: RenderingContext, instance: ColorMapInstance): void;
+    prepareCleanup(context: RenderingContext, instance: ColorMapInstance): void;
+}
+export interface ColorIndexConfig {
+    offset: number;
+    step: number | null;
+    size: number;
+}
+export declare class ColorIndex {
+    colorMap: {
+        [key: string]: number;
+    };
+    dirty: boolean;
+    offset: number;
+    step: number | null;
+    size: number;
+    constructor({ offset, step, size }: ColorIndexConfig);
+    acknowledge(name: string): void;
+    map(name: string): number;
+}

package/build/charts/ColorMap.js

@@ -0,0 +1,97 @@
+import { Widget } from "../ui/Widget";
+import { PureContainerBase } from "../ui/PureContainer";
+export class ColorMap extends Widget {
+    static Scope;
+    constructor(config) {
+        super(config);
+    }
+    declareData(...args) {
+        super.declareData(...args, {
+            names: undefined,
+            offset: undefined,
+            step: undefined,
+            size: undefined,
+        });
+    }
+    explore(context, instance) {
+        if (!context.colorMaps)
+            context.colorMaps = {};
+        context.getColorMap = (colorMap) => {
+            let map = context.colorMaps[colorMap];
+            if (!map) {
+                let cache = this.onGetCache ? instance.invoke("onGetCache") : {};
+                map = cache[colorMap];
+                if (!map) {
+                    let { data } = instance;
+                    const d = data;
+                    map = context.colorMaps[colorMap] = cache[colorMap] = new ColorIndex({
+                        offset: d.offset,
+                        step: d.step,
+                        size: d.size,
+                    });
+                }
+                const names = instance.data.names;
+                if (Array.isArray(names))
+                    names.forEach((name) => map.acknowledge(name));
+            }
+            return map;
+        };
+    }
+    render() {
+        return null;
+    }
+}
+ColorMap.prototype.offset = 0;
+ColorMap.prototype.step = null;
+ColorMap.prototype.size = 16;
+export class ColorMapScope extends PureContainerBase {
+    constructor(config) {
+        super(config);
+    }
+    explore(context, instance) {
+        context.push("colorMaps", (instance.colorMaps = {}));
+        super.explore(context, instance);
+    }
+    exploreCleanup(context, instance) {
+        context.pop("colorMaps");
+    }
+    prepare(context, instance) {
+        context.push("colorMaps", instance.colorMaps);
+    }
+    prepareCleanup(context, instance) {
+        context.pop("colorMaps");
+    }
+}
+ColorMap.Scope = ColorMapScope;
+Widget.alias("color-map", ColorMap);
+export class ColorIndex {
+    colorMap;
+    dirty;
+    offset;
+    step;
+    size;
+    constructor({ offset, step, size }) {
+        this.colorMap = {};
+        this.dirty = true;
+        this.offset = offset;
+        this.step = step;
+        this.size = size;
+    }
+    acknowledge(name) {
+        if (!(name in this.colorMap)) {
+            this.colorMap[name] = Object.keys(this.colorMap).length;
+            this.dirty = true;
+        }
+    }
+    map(name) {
+        if (this.dirty) {
+            this.dirty = false;
+            if (!this.step) {
+                let n = Object.keys(this.colorMap).length;
+                this.step = n > 0 ? this.size / n : 1;
+            }
+        }
+        let index = this.colorMap[name] || 0;
+        return Math.round(this.offset + this.step * index + this.size) % this.size;
+    }
+}

package/build/charts/Column.d.ts

@@ -0,0 +1,32 @@
+import { ColumnBarBase, ColumnBarBaseConfig, ColumnBarBaseInstance } from "./ColumnBarBase";
+import { Rect } from "../svg/util/Rect";
+import { RenderingContext } from "../ui/RenderingContext";
+import { NumberProp, BooleanProp } from "../ui/Prop";
+export interface ColumnConfig extends ColumnBarBaseConfig {
+    /** Column base value. Default value is `0`. */
+    y0?: NumberProp;
+    /** Size (width) of the column in axis units. */
+    size?: NumberProp;
+    /** Set to true to auto calculate size and offset. Available only if the x axis is a category axis. */
+    autoSize?: BooleanProp;
+    /** Alias for size. */
+    width?: number;
+    /** Minimum column size in pixels. Useful for indicating very small values. Default value is 0.5. */
+    minPixelHeight?: number;
+    /** Hide the base of the column (y0). */
+    hiddenBase?: boolean;
+}
+export declare class Column extends ColumnBarBase {
+    y0: number;
+    size: number;
+    autoSize: boolean;
+    width: number;
+    minPixelHeight: number;
+    hiddenBase: boolean;
+    constructor(config: ColumnConfig);
+    init(): void;
+    declareData(...args: any[]): any;
+    checkValid(data: any): boolean;
+    explore(context: RenderingContext, instance: ColumnBarBaseInstance): void;
+    calculateRect(instance: ColumnBarBaseInstance): Rect;
+}