@mathstack/viz 0.0.1-beta.0

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@mathstack/viz" />
+export * from './public-api';

package/lib/axes/base/config/xy-axis-builder.d.ts

@@ -0,0 +1,38 @@
+import { VicAuxMarksBuilder } from '../../../marks';
+import { AxisBaselineBuilder } from '../../baseline/axis-baseline-builder';
+import { GridBuilder } from '../../grid/grid-builder';
+import { AxisLabelBuilder } from '../../label/axis-label-builder';
+export declare abstract class XyAxisBaseBuilder extends VicAuxMarksBuilder<void> {
+    protected _axis: 'x' | 'y';
+    protected _dimension: 'ordinal' | 'quantitative';
+    protected baselineBuilder: AxisBaselineBuilder;
+    protected gridBuilder: GridBuilder;
+    protected labelBuilder: AxisLabelBuilder;
+    protected marksClass: string;
+    /**
+     * OPTIONAL. Specifies the configuration for the axis baseline. The baseline is the line that typically runs along the edge of the chart, from which tick marks and labels are drawn.
+     *
+     * @param baseline - A function that specifies properties for the axis baseline, or `null` to unset the baseline.
+     *
+     * If called with null, the default values of the baseline will be used.
+     */
+    baseline(baseline: (baseline: AxisBaselineBuilder) => void): this;
+    baseline(baseline: null): this;
+    /**
+     * OPTIONAL. Specifies the configuration of grid lines for the axis. Grid lines are the lines that run perpendicular to the axis and intersect with tick marks.
+     *
+     * @param grid - A function that specifies properties for the grid lines, or `null` to unset the grid.
+     *
+     * If called with no argument, the default values of the grid will be used.
+     */
+    grid(grid: (grid: GridBuilder) => void): this;
+    grid(): this;
+    grid(grid: null): this;
+    /**
+     * OPTIONAL. Specifies properties for an axis label.
+     *
+     * @param label - A function that specifies properties for an axis label, or `null` to unset the label.
+     */
+    label(label: (label: AxisLabelBuilder) => void): this;
+    label(label: null): this;
+}

package/lib/axes/base/config/xy-axis-config.d.ts

@@ -0,0 +1,18 @@
+import { DataValue } from '../../../core/types/values';
+import { AuxMarksConfig } from '../../../marks';
+import { AxisBaseline } from '../../baseline/axis-baseline';
+import { Grid } from '../../grid/grid-config';
+import { AxisLabel } from '../../label/axis-label';
+import { Ticks } from '../../ticks/ticks';
+import { XyAxisBaseOptions } from './xy-axis-options';
+export declare abstract class XyAxisConfig<Tick extends DataValue, TicksConfig extends Ticks<Tick>> extends AuxMarksConfig implements XyAxisBaseOptions {
+    baseline: AxisBaseline;
+    grid: Grid;
+    label: AxisLabel;
+    ticks: TicksConfig;
+    abstract getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    getValidatedNumTicks(numTicks: number): number;
+}

package/lib/axes/base/config/xy-axis-options.d.ts

@@ -0,0 +1,10 @@
+import { MarksOptions } from '../../../marks';
+import { AxisBaselineOptions } from '../../baseline/axis-baseline-options';
+import { Grid } from '../../grid/grid-config';
+import { AxisLabelOptions } from '../../label/axis-label-options';
+export interface XyAxisBaseOptions extends MarksOptions {
+    baseline: AxisBaselineOptions;
+    grid: Grid;
+    label: AxisLabelOptions;
+    marksClass: string;
+}

package/lib/axes/base/xy-axis-base.d.ts

@@ -0,0 +1,49 @@
+import { ElementRef } from '@angular/core';
+import { Selection } from 'd3';
+import { GenericScale } from '../../core';
+import { ContinuousValue, DataValue } from '../../core/types/values';
+import { XyAuxMarks } from '../../marks';
+import { Ticks } from '../ticks/ticks';
+import { XyAxisConfig } from './config/xy-axis-config';
+import * as i0 from "@angular/core";
+export type XyAxisScale = {
+    useTransition: boolean;
+    scale: GenericScale<any, any>;
+};
+type AxisSvgElements = 'gridGroup' | 'gridLine' | 'label' | 'axisGroup';
+/**
+ * A base directive for all axes.
+ */
+export declare abstract class XyAxis<Tick extends DataValue | ContinuousValue, TicksConfig extends Ticks<Tick>> extends XyAuxMarks<unknown, XyAxisConfig<Tick, TicksConfig>> {
+    axis: any;
+    axisFunction: any;
+    axisGroup: Selection<SVGGElement, any, SVGGElement, any>;
+    gridGroup: Selection<SVGGElement, any, SVGGElement, any>;
+    scale: any;
+    elRef: ElementRef<SVGGElement>;
+    isFirstDraw: boolean;
+    abstract setAxisFunction(): any;
+    abstract setTranslate(): void;
+    abstract setTicks(tickFormat: string | ((value: Tick) => string)): void;
+    abstract setScale(): void;
+    abstract createLabel(): void;
+    abstract getBaselineTranslate(): string | null;
+    get class(): Record<AxisSvgElements, string>;
+    initFromConfig(): void;
+    setAxisFromScaleAndConfig(): void;
+    setTickSize(): void;
+    drawMarks(): void;
+    drawAxis(): void;
+    processTicks(): void;
+    setTickFontSize(tickTextSelection: any): void;
+    wrapAxisTickText(tickTextSelection: any): void;
+    processDomain(): void;
+    processTickLabels(): void;
+    otherAxisHasPosAndNegValues(dimension: 'x' | 'y'): boolean;
+    drawGrid(): void;
+    getGridLineLength(): number;
+    getTransition(selection: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XyAxis<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<XyAxis<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/axes/baseline/axis-baseline-builder.d.ts

@@ -0,0 +1,31 @@
+import { AxisBaseline } from './axis-baseline';
+export declare class AxisBaselineBuilder {
+    private _display;
+    private _zeroBaseline;
+    constructor();
+    /**
+     * OPTIONAL. Determines whether the axis baseline will be displayed.
+     *
+     * @param value - `true` to display the axis baseline, `false` to remove the axis baseline.
+     *
+     * If not called, the default value is `true`.
+     */
+    display(value?: boolean): this;
+    /**
+     * OPTIONAL. Specifies properties for the axis baseline when there are positive and negative values on the perpendicular axis.
+     *
+     * @param value - { display: boolean; stroke: StrokeBuilder }
+     *
+     * If display is `true`, the axis baseline will be relocated to the zero tick mark of the perpendicular axis. This line will still be displayed even if the axis baseline at the edge of the chart is removed.
+     *
+     * If display is `false`, the axis baseline will be removed.
+     *
+     * If stroke is `null`, the axis baseline will be displayed as a dashed line.
+     */
+    zeroBaseline(value: Partial<{
+        dasharray: string;
+        display: boolean;
+    }>): this;
+    zeroBaseline(value: null): this;
+    _build(dimension: 'ordinal' | 'quantitative'): AxisBaseline;
+}

package/lib/axes/baseline/axis-baseline-options.d.ts

@@ -0,0 +1,7 @@
+export interface AxisBaselineOptions {
+    display: boolean;
+    zeroBaseline: {
+        display: boolean;
+        dasharray: string;
+    };
+}

package/lib/axes/baseline/axis-baseline.d.ts

@@ -0,0 +1,9 @@
+import { AxisBaselineOptions } from './axis-baseline-options';
+export declare class AxisBaseline implements AxisBaselineOptions {
+    readonly display: boolean;
+    readonly zeroBaseline: {
+        display: boolean;
+        dasharray: string;
+    };
+    constructor(options: AxisBaselineOptions);
+}

package/lib/axes/grid/grid-builder.d.ts

@@ -0,0 +1,29 @@
+import { StrokeBuilder } from '../../stroke/stroke-builder';
+import { Grid } from './grid-config';
+export declare class GridBuilder {
+    private _filter;
+    private strokeBuilder;
+    /**
+     * OPTIONAL. Determines whether or not to display grid lines. Must specify a function
+     *  that takes the index of the grid line and returns a boolean.
+     *
+     * Default: `(i) => i > 0`, but can be overriden to display all grid lines.
+     */
+    filter(filter: ((i: number) => boolean) | null): this;
+    /**
+     * OPTIONAL. A config for the behavior of the grid line stroke.
+     *
+     * Default color: '#cccccc'
+     * Default width: 1px
+     */
+    stroke(stroke: null): this;
+    stroke(stroke: (stroke: StrokeBuilder) => void): this;
+    private initStrokeBuilder;
+    /**
+     * @internal
+     * This function is for internal use only and should never be called by the user.
+     */
+    _build(axis: 'x' | 'y', dimension: 'quantitative' | 'ordinal'): Grid;
+    private validateBuilder;
+    private getFilterForDimension;
+}

package/lib/axes/grid/grid-config.d.ts

@@ -0,0 +1,8 @@
+import { Stroke } from '../../stroke';
+import { GridOptions } from './grid-options';
+export declare class Grid implements GridOptions {
+    axis: 'x' | 'y';
+    filter: (i: number) => boolean;
+    stroke: Stroke;
+    constructor(options: GridOptions);
+}

package/lib/axes/grid/grid-options.d.ts

@@ -0,0 +1,6 @@
+import { Stroke } from '../../stroke';
+export interface GridOptions {
+    axis: 'x' | 'y';
+    filter: (i: number) => boolean;
+    stroke: Stroke;
+}

package/lib/axes/index.d.ts

@@ -0,0 +1,13 @@
+export * from './x-ordinal/x-ordinal-axis-builder';
+export * from './x-ordinal/x-ordinal-axis-config';
+export * from './x-ordinal/x-ordinal-axis.component';
+export * from './x-quantitative/x-quantitative-axis-builder';
+export * from './x-quantitative/x-quantitative-axis-config';
+export * from './x-quantitative/x-quantitative-axis.component';
+export * from './xy-axis.module';
+export * from './y-ordinal/y-ordinal-axis-builder';
+export * from './y-ordinal/y-ordinal-axis-config';
+export * from './y-ordinal/y-ordinal-axis.component';
+export * from './y-quantitative-axis/y-quantitative-axis-builder';
+export * from './y-quantitative-axis/y-quantitative-axis-config';
+export * from './y-quantitative-axis/y-quantitative-axis.component';

package/lib/axes/label/axis-label-builder.d.ts

@@ -0,0 +1,63 @@
+import { SvgTextWrapBuilder } from '../../svg-text-wrap/svg-text-wrap-builder';
+import { AxisLabel } from './axis-label';
+export declare class AxisLabelBuilder {
+    protected _anchor: 'start' | 'middle' | 'end';
+    protected _offset: {
+        x: number;
+        y: number;
+    };
+    protected _position: 'start' | 'middle' | 'end';
+    protected _text: string;
+    protected textWrapBuilder: SvgTextWrapBuilder;
+    protected textWrapFunction: (wrap: SvgTextWrapBuilder) => void;
+    constructor();
+    /**
+     * OPTIONAL. The [text-anchor](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/text-anchor) for the axis label.
+     *
+     * If not provided or if called with null, the anchor will be determined by the position.
+     *
+     * @default specific to the position
+     */
+    anchor(value: 'start' | 'middle' | 'end' | null): this;
+    /**
+     * OPTIONAL. The offset for the axis label from the position that would otherwise be created. Allows for fine-tuning the position of the label.
+     *
+     * Positive y values will move the label down, positive x values will move the label to the right.
+     *
+     * If not provided or if called with null, labels parallel to the axis will be placed at the far extent of the margin. Labels perpendicular to the axis will be placed at the axis line. The latter will likely need an offset.
+     *
+     * @default { x: 0, y: 0 }
+     */
+    offset(offset: null): this;
+    offset(offset: {
+        x?: number;
+        y?: number;
+    }): this;
+    /**
+     * OPTIONAL. The position of the axis label relative to the axis.
+     *
+     * If the axis is horizontal, the options are 'start' is left, 'middle' is center, and 'end' is right.
+     *
+     * If the axis is vertical, the options are 'start' is top, 'middle' is center, and 'end' is bottom.
+     *
+     * @default 'middle'
+     */
+    position(value: 'start' | 'middle' | 'end'): this;
+    /**
+     * The text for the axis label.
+     */
+    text(value: string): this;
+    /**
+     * OPTIONAL. Specifies properties for wrapping the text of the label.
+     *
+     * To unset the wrap, call with null.
+     */
+    wrap(wrap: null): this;
+    wrap(wrap: (wrap: SvgTextWrapBuilder) => void): this;
+    /**
+     * @internal Not meant to be called by consumers of the library.
+     */
+    _build(dimension: 'x' | 'y'): AxisLabel;
+    private createTextWrapBuilder;
+    private getAnchorForDimension;
+}

package/lib/axes/label/axis-label-options.d.ts

@@ -0,0 +1,11 @@
+import { SvgTextWrap } from '../../svg-text-wrap';
+export interface AxisLabelOptions {
+    anchor: 'start' | 'middle' | 'end';
+    offset: {
+        x: number;
+        y: number;
+    };
+    position: 'start' | 'middle' | 'end';
+    text: string;
+    wrap: SvgTextWrap;
+}

package/lib/axes/label/axis-label.d.ts

@@ -0,0 +1,13 @@
+import { SvgTextWrap } from '../../svg-text-wrap';
+import { AxisLabelOptions } from './axis-label-options';
+export declare class AxisLabel implements AxisLabelOptions {
+    anchor: 'start' | 'middle' | 'end';
+    offset: {
+        x: number;
+        y: number;
+    };
+    position: 'start' | 'middle' | 'end';
+    text: string;
+    wrap: SvgTextWrap;
+    constructor(options: AxisLabelOptions);
+}

package/lib/axes/ordinal/ordinal-axis-config.d.ts

@@ -0,0 +1,38 @@
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { DataValue } from '../../core/types/values';
+import { XyAxisConfig } from '../base/config/xy-axis-config';
+import { XyAxisBaseOptions } from '../base/config/xy-axis-options';
+import { Ticks } from '../ticks/ticks';
+import { TicksOptions } from '../ticks/ticks-options';
+export interface VicOrdinalAxisOptions<Tick extends DataValue> extends XyAxisBaseOptions {
+    ticks: TicksOptions<Tick>;
+}
+export declare function mixinOrdinalAxisConfig<Tick extends DataValue, T extends AbstractConstructor<XyAxisConfig<Tick, Ticks<Tick>>>>(Base: T): (abstract new (...args: any[]) => {
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: Ticks<Tick>;
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & T;
+declare const VicOrdinalAxisConfig_base: (abstract new (...args: any[]) => {
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: Ticks<DataValue>;
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & typeof XyAxisConfig;
+export declare abstract class VicOrdinalAxisConfig<Tick extends DataValue> extends VicOrdinalAxisConfig_base<Tick, Ticks<Tick>> {
+}
+export {};

package/lib/axes/ordinal/ordinal-axis.d.ts

@@ -0,0 +1,43 @@
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { DataValue } from '../../core/types/values';
+import { XyAxis } from '../base/xy-axis-base';
+import { Ticks } from '../ticks/ticks';
+import { VicOrdinalAxisConfig as OrdinalAxisConfig } from './ordinal-axis-config';
+export declare function ordinalAxisMixin<Tick extends DataValue, T extends AbstractConstructor<XyAxis<Tick, Ticks<Tick>>>>(Base: T): (abstract new (...args: any[]) => {
+    config: OrdinalAxisConfig<Tick>;
+    setTicks(tickFormat: string | ((value: Tick) => string)): void;
+    axis: any;
+    axisFunction: any;
+    axisGroup: import("d3-selection").Selection<SVGGElement, any, SVGGElement, any>;
+    gridGroup: import("d3-selection").Selection<SVGGElement, any, SVGGElement, any>;
+    scale: any;
+    elRef: import("@angular/core").ElementRef<SVGGElement>;
+    isFirstDraw: boolean;
+    setAxisFunction(): any;
+    setTranslate(): void;
+    setScale(): void;
+    createLabel(): void;
+    getBaselineTranslate(): string | null;
+    readonly class: Record<"label" | "gridGroup" | "gridLine" | "axisGroup", string>;
+    initFromConfig(): void;
+    setAxisFromScaleAndConfig(): void;
+    setTickSize(): void;
+    drawMarks(): void;
+    drawAxis(): void;
+    processTicks(): void;
+    setTickFontSize(tickTextSelection: any): void;
+    wrapAxisTickText(tickTextSelection: any): void;
+    processDomain(): void;
+    processTickLabels(): void;
+    otherAxisHasPosAndNegValues(dimension: "x" | "y"): boolean;
+    drawGrid(): void;
+    getGridLineLength(): number;
+    getTransition(selection: any): any;
+    scales: import("@mathstack/viz").XyChartScales;
+    chart: import("@mathstack/viz").XyChartComponent;
+    destroyRef: import("@angular/core").DestroyRef;
+    ngOnInit(): void;
+    subscribeToScales(): void;
+    getTransitionDuration(): number;
+    ngOnChanges(changes: import("@angular/core").SimpleChanges): void;
+}) & T;

package/lib/axes/quantitative/quantitative-axis-config.d.ts

@@ -0,0 +1,38 @@
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { ContinuousValue } from '../../core/types/values';
+import { XyAxisConfig } from '../base/config/xy-axis-config';
+import { XyAxisBaseOptions } from '../base/config/xy-axis-options';
+import { QuantitativeTicks } from '../ticks/ticks';
+import { QuantitativeTicksOptions } from '../ticks/ticks-options';
+export interface VicQuantitativeAxisOptions<Tick extends ContinuousValue> extends XyAxisBaseOptions {
+    ticks: QuantitativeTicksOptions<Tick>;
+}
+export declare function mixinQuantitativeAxisConfig<Tick extends ContinuousValue, T extends AbstractConstructor<XyAxisConfig<Tick, QuantitativeTicks<Tick>>>>(Base: T): (abstract new (...args: any[]) => {
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: QuantitativeTicks<Tick>;
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & T;
+declare const VicQuantitativeAxisConfig_base: (abstract new (...args: any[]) => {
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: QuantitativeTicks<ContinuousValue>;
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & typeof XyAxisConfig;
+export declare abstract class VicQuantitativeAxisConfig<Tick extends ContinuousValue> extends VicQuantitativeAxisConfig_base<Tick, QuantitativeTicks<Tick>> {
+}
+export {};

package/lib/axes/quantitative/quantitative-axis.d.ts

@@ -0,0 +1,51 @@
+import { AxisTimeInterval } from 'd3';
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { ContinuousValue } from '../../core/types/values';
+import { XyAxis } from '../base/xy-axis-base';
+import { QuantitativeTicks } from '../ticks/ticks';
+import { VicQuantitativeAxisConfig as QuantitativeAxisConfig } from './quantitative-axis-config';
+export declare function quantitativeAxisMixin<Tick extends ContinuousValue, T extends AbstractConstructor<XyAxis<Tick, QuantitativeTicks<Tick>>>>(Base: T): (abstract new (...args: any[]) => {
+    config: QuantitativeAxisConfig<Tick>;
+    setTicks(tickFormat: string | ((value: Tick) => string)): void;
+    setSpecifiedTickValues(tickFormat: string | ((value: Tick) => string)): void;
+    getValidTickValues(): Tick[];
+    setUnspecifiedTickValues(tickFormat: string | ((value: Tick) => string)): void;
+    getSuggestedNumTicks(tickFormat: string | ((value: Tick) => string)): number | AxisTimeInterval;
+    getNumTicks(): number | AxisTimeInterval;
+    getValidNumTicksForNumberFormatString(numTicks: number, tickFormat: string): number;
+    getMaxTicksForDateFormat(tickFormat: string): number | null;
+    axis: any;
+    axisFunction: any;
+    axisGroup: import("d3-selection").Selection<SVGGElement, any, SVGGElement, any>;
+    gridGroup: import("d3-selection").Selection<SVGGElement, any, SVGGElement, any>;
+    scale: any;
+    elRef: import("@angular/core").ElementRef<SVGGElement>;
+    isFirstDraw: boolean;
+    setAxisFunction(): any;
+    setTranslate(): void;
+    setScale(): void;
+    createLabel(): void;
+    getBaselineTranslate(): string | null;
+    readonly class: Record<"label" | "gridGroup" | "gridLine" | "axisGroup", string>;
+    initFromConfig(): void;
+    setAxisFromScaleAndConfig(): void;
+    setTickSize(): void;
+    drawMarks(): void;
+    drawAxis(): void;
+    processTicks(): void;
+    setTickFontSize(tickTextSelection: any): void;
+    wrapAxisTickText(tickTextSelection: any): void;
+    processDomain(): void;
+    processTickLabels(): void;
+    otherAxisHasPosAndNegValues(dimension: "x" | "y"): boolean;
+    drawGrid(): void;
+    getGridLineLength(): number;
+    getTransition(selection: any): any;
+    scales: import("@mathstack/viz").XyChartScales;
+    chart: import("@mathstack/viz").XyChartComponent;
+    destroyRef: import("@angular/core").DestroyRef;
+    ngOnInit(): void;
+    subscribeToScales(): void;
+    getTransitionDuration(): number;
+    ngOnChanges(changes: import("@angular/core").SimpleChanges): void;
+}) & T;

package/lib/axes/ticks/tick-wrap/tick-wrap-builder.d.ts

@@ -0,0 +1,64 @@
+import { TickWrap } from './tick-wrap';
+export declare class TickWrapBuilder {
+    _width: 'bandwidth' | number | ((chartWidth: number, numOfTicks: number) => number);
+    _maintainXPosition: boolean;
+    _maintainYPosition: boolean;
+    _lineHeight: number;
+    _breakOnChars: string[];
+    _spaceAroundBreakChars: boolean;
+    constructor();
+    /**
+     * OPTIONAL. Sets the characters to break on when wrapping text.
+     * By default, text will only break on spaces.
+     *
+     * @default []
+     */
+    breakOnChars(breakOnChars: string[]): this;
+    /**
+     * OPTIONAL. Sets the line-height property of the tick labels. Adjusting the line-height can useful when wrapping labels, particularly on a y-axis.
+     *
+     * @param value - The line-height of the tick labels, as a multiplier of the font size. For example, 1.1 is 110% of the font size, 1.5 is 150% of the font size, etc.
+     */
+    lineHeight(value: number | null): this;
+    /**
+     * OPTIONAL. If true, the x position of the text will be maintained.
+     *
+     * This is useful, for example, for centering bar labels on a vertical bar chart.
+     *
+     * @default false
+     */
+    maintainXPosition(maintainXPosition: boolean): this;
+    /**
+     * OPTIONAL. If true, the y position of the text will be maintained.
+     *
+     * This is useful, for example, for centering bar labels on a horizontal bar chart.
+     *
+     * @default false
+     */
+    maintainYPosition(maintainYPosition: boolean): this;
+    /**
+     * OPTIONAL. If true, spaces will be added around break characters.
+     *
+     * This is useful when breaking on punctuation characters, to avoid words being stuck to punctuation.
+     * For example, breaking on commas without spaces around them would result in "word," at the end of one line and "word" at the start of the next line.
+     *
+     * @default false
+     */
+    spaceAroundBreakChars(spaceAroundBreakChars: boolean): this;
+    /**
+     * OPTIONAL. Sets the width to wrap the text to. Can be a number, a function that takes the chart width and number of ticks, or 'bandwidth'.
+     *
+     * If 'bandwidth', the width will be the bandwidth of the scale.
+     *
+     * @default 'bandwidth'
+     */
+    width(width: 'bandwidth'): this;
+    width(width: number): this;
+    width(width: (chartWidth: number, numOfTicks: number) => number): this;
+    width(width: null): this;
+    /**
+     * @internal Not meant to be called by consumers of the library.
+     */
+    _build(dimension: 'x' | 'y'): TickWrap;
+    private validate;
+}

package/lib/axes/ticks/tick-wrap/tick-wrap-options.d.ts

@@ -0,0 +1,8 @@
+export interface TickWrapOptions {
+    width: 'bandwidth' | number | ((chartWidth: number, numOfTicks: number) => number);
+    maintainXPosition: boolean;
+    maintainYPosition: boolean;
+    lineHeight: number;
+    breakOnChars: string[];
+    spaceAroundBreakChars: boolean;
+}

package/lib/axes/ticks/tick-wrap/tick-wrap.d.ts

@@ -0,0 +1,13 @@
+import { TickWrapOptions } from './tick-wrap-options';
+/**
+ * A config that specifies how axis tick labels should wrap.
+ */
+export declare class TickWrap {
+    maintainXPosition: boolean;
+    maintainYPosition: boolean;
+    lineHeight: number;
+    breakOnChars: string[];
+    spaceAroundBreakChars: boolean;
+    width: 'bandwidth' | number | ((chartWidth: number, numOfTicks: number) => number);
+    constructor(options: TickWrapOptions);
+}