@mathstack/viz 0.0.1-beta.0

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

@@ -0,0 +1,172 @@
+import { AxisTimeInterval } from 'd3';
+import { TickWrapBuilder } from './tick-wrap/tick-wrap-builder';
+import { QuantitativeTicks, Ticks } from './ticks';
+export interface AxisSpecificTickBuilderOptions {
+    _sizeOuter: number;
+}
+export interface AxisSpecificQuantitativeTickBuilderOptions<Tick> extends AxisSpecificTickBuilderOptions {
+    _format: string | ((value: Tick) => string);
+}
+export declare class TicksBuilder<Tick> {
+    protected _class: (d: Tick) => string;
+    protected _fontSize: number;
+    protected _format: string | ((value: Tick) => string);
+    protected _labelsDisplay: boolean;
+    protected _rotate: number;
+    protected _labelsStroke: string;
+    protected _labelsStrokeOpacity: number;
+    protected _labelsStrokeWidth: number;
+    protected _marksDisplay: boolean;
+    protected _size: number;
+    protected _sizeInner: number;
+    protected _sizeOuter: number;
+    protected wrapBuilder: TickWrapBuilder;
+    constructor(options: Partial<AxisSpecificTickBuilderOptions>);
+    /**
+     * OPTIONAL. Provides a class on the SVG G element that corresponds to a single tick.
+     *
+     * Note that if the resultant string has spaces in the name, multiple classes will be applied. For example, if the class is 'North Carolina', the element will have the classes 'North' and 'Carolina'.
+     */
+    class(value: null): this;
+    class(value: string): this;
+    class(value: (d: Tick) => string): this;
+    /**
+     * OPTIONAL. Sets the font size of the tick labels.
+     *
+     * @param value - The font size of the tick labels, in px.
+     *
+     * If not called, the default font size is D3's default, which is 10px.
+     */
+    fontSize(value: number | null): this;
+    /**
+     * OPTIONAL. Specifies how tick labels will be formatted. The format can be a string or a function.
+     *
+     * @param value - Either a D3 format string, a function that takes a value and returns a string, or `null` to unset the format.
+     *
+     * If not called, the default value for quantitative axes is ',.1f'. If not called for an ordinal axis, tick labels will be the unformatted ordinal value.
+     */
+    format(format: string): this;
+    format(format: (value: Tick) => string): this;
+    format(format: null): this;
+    /**
+     * OPTIONAL. If false, tick labels will be removed.
+     *
+     * @param value - `true` to retain all tick labels, `false` to remove all tick labels.
+     *
+     * If not called, the default value is `true`.
+     */
+    labelsDisplay(value: boolean): this;
+    /**
+     * OPTIONAL. Sets the color of the stroke around the tick labels. Often used to improve the legibility of tick labels, for example, on dark backgrounds.
+     *
+     * @param value - The stroke of the tick labels.
+     *
+     * If not called, the default value is 'none'.
+     */
+    labelsStroke(value: string | null): this;
+    /**
+     * OPTIONAL. Sets the opacity of the stroke applied around the tick labels.
+     *
+     * @param value - The opacity of the stroke around the tick labels.
+     *
+     * If not called, the default value is 1.
+     */
+    labelsStrokeOpacity(value: number | null): this;
+    /**
+     * OPTIONAL. Sets the width of the stroke around the tick labels. Often used to improve the legibility of tick labels, for example, on dark backgrounds.
+     *
+     * @param value - The width of the stroke around the tick labels.
+     *
+     * If not called, the default value is 3.
+     */
+    labelsStrokeWidth(value: number | null): this;
+    /**
+     * OPTIONAL. If false, tick marks (lines) will be removed.
+     *
+     * @param value - `true` to retain all tick marks, `false` to remove all tick marks.
+     *
+     * If not called, the default value is `true`.
+     */
+    marksDisplay(value: boolean): this;
+    /**
+     * OPTIONAL. Determines the rotation of tick labels.
+     *
+     * @param value - The rotation of the tick labels in degrees, or `null` to unset the rotation.
+     *
+     * Positive values rotate clockwise, negative values rotate counterclockwise.
+     *
+     * If not called, ticks will not be rotated.
+     */
+    rotate(value: number | null): this;
+    /**
+     * OPTIONAL. Sets the size of inner and outer tick marks.
+     *
+     * @param value - The size of the ticks, in px.
+     *
+     * If not called or called with `null`, the default size is the D3 default size.
+     *
+     * If specified, this value will override any values set by `sizeInner` or `sizeOuter`.
+     */
+    size(value: number | null): this;
+    /**
+     * OPTIONAL. Determines the length of the inner ticks drawn by D3. Does not apply to the outermost ticks.
+     *
+     * @param value - The length of the inner ticks in pixels, or `null` to unset the value.
+     *
+     * If not called or called with `null`, the default value is the D3 default size.
+     *
+     */
+    sizeInner(value: number | null): this;
+    /**
+     * OPTIONAL. Determines the length of the square ends of the domain path drawn by D3.
+     *
+     * @param value - The length of the square ends of the domain path in pixels, or `null` to unset the value.
+     *
+     * If not called on ordinal axes, the default value is 0. If not called on quantitative axes, no modification is made to D3's default value.
+     */
+    sizeOuter(value: number | null): this;
+    /**
+     * OPTIONAL. Specifies how tick labels will be wrapped.
+     *
+     * @param wrap - A callback that specifies how tick labels will be wrapped, or `null` to unset the wrapping.
+     *
+     * If not called, the tick labels will not be wrapped.
+     */
+    wrap(wrap: (wrap: TickWrapBuilder) => void): this;
+    wrap(wrap: null): this;
+    _build(dimension: 'x' | 'y'): Ticks<Tick>;
+}
+export declare class QuantitativeTicksBuilder<Tick> extends TicksBuilder<Tick> {
+    private _count;
+    private _spacing;
+    private _values;
+    constructor(options: Partial<AxisSpecificQuantitativeTickBuilderOptions<Tick>>);
+    /**
+     * OPTIONAL. Approximately specifies the number of ticks for the axis.
+     *
+     * @param value - The number of ticks to pass to D3's axis.ticks(), or null to unset the number of ticks.
+     *
+     * If not called, a reasonable and valid default will be used based on the size of the chart.
+     *
+     * Note that this number will be passed to D3's `ticks()` method and therefore it can be an approximate number of ticks.
+     *
+     * If this method is called, the passed in number of ticks will be validated against the data domain and the value formatter for the axis. If the number of ticks is not valid—for example, if the ticks are formatted with %Y and there are three years of values in the data, and this method is called with 10, a valid number will be used instead.
+     */
+    count(value: number | AxisTimeInterval | null): this;
+    /**
+     * OPTIONAL. Specifies the an approximate spacing between ticks, in pixels.
+     *
+     * @param value - The spacing between ticks in pixels, or null to unset the spacing.
+     *
+     * If not called, the default value is 40. If `count` is set, this value will be ignored.
+     */
+    spacing(value: number | null): this;
+    /**
+     * OPTIONAL. Determines the values that will show up as ticks on the axis.
+     *
+     * @param values - An array of quantitative values to pass to D3's axis.tickValues(), or null to unset the tick values.
+     *
+     */
+    values(values: Tick[] | null): this;
+    _build(dimension: 'x' | 'y'): QuantitativeTicks<Tick>;
+}

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

@@ -0,0 +1,22 @@
+import { AxisTimeInterval } from 'd3';
+import { TickWrap } from './tick-wrap/tick-wrap';
+export interface TicksOptions<Tick> {
+    class: (d: Tick) => string;
+    fontSize: number;
+    format: string | ((value: Tick) => string);
+    labelsDisplay: boolean;
+    labelsStroke: string;
+    labelsStrokeOpacity: number;
+    labelsStrokeWidth: number;
+    marksDisplay: boolean;
+    rotate: number;
+    size: number;
+    sizeInner: number;
+    sizeOuter: number;
+    wrap: TickWrap;
+}
+export interface QuantitativeTicksOptions<Tick> extends TicksOptions<Tick> {
+    count: number | AxisTimeInterval;
+    spacing: number;
+    values: Tick[];
+}

package/lib/axes/ticks/ticks.d.ts

@@ -0,0 +1,24 @@
+import { TickWrap } from './tick-wrap/tick-wrap';
+import { QuantitativeTicksOptions, TicksOptions } from './ticks-options';
+export declare class Ticks<Tick> implements TicksOptions<Tick> {
+    class: (d: Tick) => string;
+    fontSize: number;
+    format: string | ((value: Tick) => string);
+    labelsDisplay: boolean;
+    labelsStroke: string;
+    labelsStrokeOpacity: number;
+    labelsStrokeWidth: number;
+    marksDisplay: boolean;
+    rotate: number;
+    size: number;
+    sizeInner: number;
+    sizeOuter: number;
+    wrap: TickWrap;
+    constructor(options: TicksOptions<Tick>);
+}
+export declare class QuantitativeTicks<Tick> extends Ticks<Tick> {
+    count: number;
+    spacing: number;
+    values: Tick[];
+    constructor(options: QuantitativeTicksOptions<Tick>);
+}

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

@@ -0,0 +1,42 @@
+import { DataValue } from '../../core';
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { XyAxisConfig } from '../base/config/xy-axis-config';
+import { XyAxisBaseOptions } from '../base/config/xy-axis-options';
+import { Ticks } from '../ticks/ticks';
+export interface XAxisOptions extends XyAxisBaseOptions {
+    /**
+     * The side of the chart on which the axis will be placed.
+     */
+    side: 'top' | 'bottom';
+}
+export declare function mixinXAxisConfig<Tick extends DataValue, TicksConfig extends Ticks<Tick>, T extends AbstractConstructor<XyAxisConfig<Tick, TicksConfig>>>(Base: T): (abstract new (...args: any[]) => {
+    side: "top" | "bottom";
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: TicksConfig;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & T;
+declare const XAxisConfig_base: (abstract new (...args: any[]) => {
+    side: "top" | "bottom";
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: Ticks<DataValue>;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & typeof XyAxisConfig;
+export declare class XAxisConfig<Tick extends DataValue, TicksConfig extends Ticks<Tick>> extends XAxisConfig_base<Tick, TicksConfig> {
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { ContinuousValue, DataValue } from '../../core/types/values';
+import { XyAxis } from '../base/xy-axis-base';
+import { Ticks } from '../ticks/ticks';
+import { XAxisConfig } from './x-axis-config';
+export declare function xAxisMixin<Tick extends DataValue | ContinuousValue, TicksConfig extends Ticks<Tick>, T extends AbstractConstructor<XyAxis<Tick, TicksConfig>>>(Base: T): (abstract new (...args: any[]) => {
+    config: XAxisConfig<Tick, TicksConfig>;
+    translate: string;
+    setTranslate(): void;
+    getTranslateDistance(): number;
+    getTopTranslate(): number;
+    getBottomTranslate(): number;
+    getBaselineTranslate(): string | null;
+    setScale(): void;
+    setAxisFunction(): void;
+    createLabel(): 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;
+    setTicks(tickFormat: string | ((value: Tick) => string)): void;
+    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/x-ordinal/x-ordinal-axis-builder.d.ts

@@ -0,0 +1,29 @@
+import { DataValue } from '../../core/types/values';
+import { XyAxisBaseBuilder } from '../base/config/xy-axis-builder';
+import { TicksBuilder } from '../ticks/ticks-builder';
+import { VicXOrdinalAxisConfig } from './x-ordinal-axis-config';
+import * as i0 from "@angular/core";
+export declare class VicXOrdinalAxisConfigBuilder<Tick extends DataValue> extends XyAxisBaseBuilder {
+    private _side;
+    private ticksBuilder;
+    constructor();
+    /**
+     * OPTIONAL. Specifies the location of the axis on the chart.
+     *
+     * @param value - The side of the chart where the axis will be placed.
+     *
+     * If not called, the default value is `bottom`.
+     */
+    side(value: 'top' | 'bottom'): this;
+    /**
+     * OPTIONAL. Specifies properties for axis ticks.
+     *
+     * @param ticks - A function that specifies properties for axis ticks.
+     */
+    ticks(ticks: (ticks: TicksBuilder<Tick>) => void): this;
+    ticks(ticks: null): this;
+    private getTicksBuilder;
+    getConfig(): VicXOrdinalAxisConfig<Tick>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicXOrdinalAxisConfigBuilder<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicXOrdinalAxisConfigBuilder<any>>;
+}

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

@@ -0,0 +1,25 @@
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { DataValue } from '../../core/types/values';
+import { XyAxisConfig } from '../base/config/xy-axis-config';
+import { VicOrdinalAxisOptions } from '../ordinal/ordinal-axis-config';
+import { Ticks } from '../ticks/ticks';
+import { XAxisOptions } from '../x/x-axis-config';
+type XyAxisConfigType<T extends DataValue> = AbstractConstructor<XyAxisConfig<T, Ticks<T>>>;
+declare const AbstractXOrdinalAxis: (abstract new (...args: any[]) => {
+    side: "top" | "bottom";
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: Ticks<DataValue>;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & XyAxisConfigType<DataValue>;
+export declare class VicXOrdinalAxisConfig<Tick extends DataValue> extends AbstractXOrdinalAxis {
+    constructor(options: XAxisOptions & VicOrdinalAxisOptions<Tick>);
+}
+export {};

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

@@ -0,0 +1,88 @@
+import { DataValue } from '../../core/types/values';
+import { XyAxis } from '../base/xy-axis-base';
+import { Ticks } from '../ticks/ticks';
+import * as i0 from "@angular/core";
+declare const XOrdinalAxis: (abstract new (...args: any[]) => {
+    config: import("../x/x-axis-config").XAxisConfig<string | number | Date, Ticks<string | number | Date>>;
+    translate: string;
+    setTranslate(): void;
+    getTranslateDistance(): number;
+    getTopTranslate(): number;
+    getBottomTranslate(): number;
+    getBaselineTranslate(): string | null;
+    setScale(): void;
+    setAxisFunction(): void;
+    createLabel(): 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;
+    setTicks(tickFormat: string | ((value: string | number | Date) => string)): void;
+    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;
+}) & (abstract new (...args: any[]) => {
+    config: import("../ordinal/ordinal-axis-config").VicOrdinalAxisConfig<DataValue>;
+    setTicks(tickFormat: string | ((value: DataValue) => 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;
+}) & (abstract new () => XyAxis<DataValue, Ticks<DataValue>>);
+export declare class XOrdinalAxisComponent extends XOrdinalAxis {
+    static ɵfac: i0.ɵɵFactoryDeclaration<XOrdinalAxisComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<XOrdinalAxisComponent, "[vic-x-ordinal-axis]", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ContinuousValue } from '../../core/types/values';
+import { XyAxisBaseBuilder } from '../base/config/xy-axis-builder';
+import { QuantitativeTicksBuilder } from '../ticks/ticks-builder';
+import { VicXQuantitativeAxisConfig } from './x-quantitative-axis-config';
+import * as i0 from "@angular/core";
+export declare class VicXQuantitativeAxisConfigBuilder<Tick extends ContinuousValue> extends XyAxisBaseBuilder {
+    private ticksBuilder;
+    private _side;
+    constructor();
+    /**
+     * OPTIONAL. Specifies the location of the axis on the chart.
+     *
+     * @param value - The side of the chart where the axis will be placed.
+     *
+     * If not called, the default value is `bottom`.
+     */
+    side(value: 'top' | 'bottom'): this;
+    /**
+     * OPTIONAL. Specifies properties for axis ticks.
+     *
+     * @param ticks - A function that specifies properties for axis ticks.
+     */
+    ticks(ticks: (ticks: QuantitativeTicksBuilder<Tick>) => void): this;
+    ticks(ticks: null): this;
+    private getTicksBuilder;
+    getConfig(): VicXQuantitativeAxisConfig<Tick>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicXQuantitativeAxisConfigBuilder<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicXQuantitativeAxisConfigBuilder<any>>;
+}

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

@@ -0,0 +1,25 @@
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { ContinuousValue } from '../../core/types/values';
+import { XyAxisConfig } from '../base/config/xy-axis-config';
+import { VicQuantitativeAxisOptions } from '../quantitative/quantitative-axis-config';
+import { QuantitativeTicks } from '../ticks/ticks';
+import { XAxisOptions } from '../x/x-axis-config';
+type XyAxisConfigType<T extends ContinuousValue> = AbstractConstructor<XyAxisConfig<T, QuantitativeTicks<T>>>;
+declare const AbstractXQuantitativeAxis: (abstract new (...args: any[]) => {
+    side: "top" | "bottom";
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: QuantitativeTicks<ContinuousValue>;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & XyAxisConfigType<ContinuousValue>;
+export declare class VicXQuantitativeAxisConfig<Tick extends ContinuousValue> extends AbstractXQuantitativeAxis {
+    constructor(options: XAxisOptions & VicQuantitativeAxisOptions<Tick>);
+}
+export {};

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

@@ -0,0 +1,53 @@
+import { ContinuousValue } from '../../core';
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { XyAxis } from '../base/xy-axis-base';
+import { QuantitativeTicks, Ticks } from '../ticks/ticks';
+import * as i0 from "@angular/core";
+type XyAxisType<T extends ContinuousValue> = AbstractConstructor<XyAxis<T, QuantitativeTicks<T>>>;
+declare const XQuantitativeAxis: (abstract new (...args: any[]) => {
+    config: import("../x/x-axis-config").XAxisConfig<ContinuousValue, Ticks<ContinuousValue>>;
+    translate: string;
+    setTranslate(): void;
+    getTranslateDistance(): number;
+    getTopTranslate(): number;
+    getBottomTranslate(): number;
+    getBaselineTranslate(): string | null;
+    setScale(): void;
+    setAxisFunction(): void;
+    createLabel(): 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;
+    setTicks(tickFormat: string | ((value: ContinuousValue) => string)): void;
+    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;
+}) & XyAxisType<ContinuousValue>;
+export declare class XQuantitativeAxisComponent extends XQuantitativeAxis {
+    static ɵfac: i0.ɵɵFactoryDeclaration<XQuantitativeAxisComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<XQuantitativeAxisComponent, "[vic-x-quantitative-axis]", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./y-quantitative-axis/y-quantitative-axis.component";
+import * as i2 from "./y-ordinal/y-ordinal-axis.component";
+import * as i3 from "./x-quantitative/x-quantitative-axis.component";
+import * as i4 from "./x-ordinal/x-ordinal-axis.component";
+export declare class VicXyAxisModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicXyAxisModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VicXyAxisModule, never, [typeof i1.YQuantitativeAxisComponent, typeof i2.YOrdinalAxisComponent, typeof i3.XQuantitativeAxisComponent, typeof i4.XOrdinalAxisComponent], [typeof i1.YQuantitativeAxisComponent, typeof i2.YOrdinalAxisComponent, typeof i3.XQuantitativeAxisComponent, typeof i4.XOrdinalAxisComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VicXyAxisModule>;
+}

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

@@ -0,0 +1,42 @@
+import { DataValue } from '../../core';
+import { AbstractConstructor } from '../../core/common-behaviors/constructor';
+import { XyAxisConfig } from '../base/config/xy-axis-config';
+import { XyAxisBaseOptions } from '../base/config/xy-axis-options';
+import { Ticks } from '../ticks/ticks';
+export interface YAxisOptions extends XyAxisBaseOptions {
+    /**
+     * The side of the chart on which the axis will be placed.
+     */
+    side: 'left' | 'right';
+}
+export declare function mixinYAxisConfig<Tick extends DataValue, TicksConfig extends Ticks<Tick>, T extends AbstractConstructor<XyAxisConfig<Tick, TicksConfig>>>(Base: T): (abstract new (...args: any[]) => {
+    side: "left" | "right";
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: TicksConfig;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & T;
+declare const YAxisConfig_base: (abstract new (...args: any[]) => {
+    side: "left" | "right";
+    getNumTicksBySpacing(spacing: number, dimensions: {
+        height: number;
+        width: number;
+    }): number;
+    baseline: import("../baseline/axis-baseline").AxisBaseline;
+    grid: import("../grid/grid-config").Grid;
+    label: import("../label/axis-label").AxisLabel;
+    ticks: Ticks<DataValue>;
+    getValidatedNumTicks(numTicks: number): number;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+}) & typeof XyAxisConfig;
+export declare class YAxisConfig<Tick extends DataValue, TicksConfig extends Ticks<Tick>> extends YAxisConfig_base<Tick, TicksConfig> {
+}
+export {};