@nova-ui/charts
Version:
Nova Charts is a library created to provide potential consumers with solutions for various data visualizations that conform with the Nova Design Language. It's designed to solve common patterns identified by UX designers, but also be very flexible so that
331 lines • 44.6 kB
JavaScript
// © 2022 SolarWinds Worldwide, LLC. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import { select } from "d3-selection";
import each from "lodash/each";
import isEmpty from "lodash/isEmpty";
import { Lasagna } from "../common/lasagna";
import { UtilityService } from "../common/utility.service";
import { GridConfig } from "./config/grid-config";
export const borderMidpoint = 0.5;
/**
* @implements {IGrid}
* Implementation for the dimensions, scaling, interactive area, and borders of a basic grid
*/
export class Grid {
/** Class name for the grid */
static GRID_CLASS_NAME = "nui-chart-grid";
/** Class name applied to each of the grid's borders by default */
static DEFAULT_BORDER_CLASS_NAME = "nui-chart-border";
/** Prefix applied to the rendering area clip path id */
static RENDERING_AREA_CLIP_PATH_PREFIX = "clip-path_";
/** Name for the lasagna layer containing the grid's rendered elements */
static GRID_ELEMENTS_LAYER_NAME = "grid-elements";
/** Name for the rendering area lasagna layer */
static RENDERING_AREA_LAYER_NAME = "rendering-area";
/** @ignore Height correction needed to prevent interaction gap between vertically stacked charts */
static RENDER_AREA_HEIGHT_CORRECTION = 1;
/** @ignore Width correction needed to prevent interaction gap between right side of grid and the edge of the rendering area */
static RENDER_AREA_WIDTH_CORRECTION = 1;
/** @ignore Width correction needed to sync bottom border length and grid width to tick placement */
static TICK_DIMENSION_CORRECTION = 1;
/** Subject for indicating that the chart's dimensions should be updated */
updateChartDimensionsSubject;
/** Event bus provided by the chart */
eventBus;
/** d3 container for the grid */
container;
/** d3 selection for the grid's rendering area clip path */
renderingAreaClipPath;
/** d3 selection for the grid's rendering area */
renderingArea;
/** d3 selection for the grid's interactive area */
interactiveArea;
/** The grid's layer manager */
lasagna;
/** Lasagna layer for the grid's rendered elements */
gridElementsLayer;
/** Definition of the grid's borders as rendered */
borders = {};
/** Property value of the grid's scales */
_scales;
/** Property value of the grid's configuration */
_config;
/** Property value of the grid's target d3 selection */
_target;
/** See {@link IGrid#getInteractiveArea} */
getInteractiveArea() {
return this.interactiveArea;
}
/** See {@link IGrid#getLasagna} */
getLasagna() {
return this.lasagna;
}
/** @ignore */
set scales(scales) {
this._scales = scales;
}
/** @ignore */
get scales() {
return this._scales;
}
/** See {@link IGrid#config} */
config(config) {
if (config === undefined) {
return this._config;
}
this._config = config;
return this;
}
/** See {@link IGrid#target} */
target(target) {
if (target === undefined) {
return this._target;
}
this._target = target;
return this;
}
/** See {@link IGrid#build} */
build() {
if (!this.config()) {
const config = new GridConfig();
this.config(config);
}
this.container = this._target.append("g").attrs({
class: Grid.GRID_CLASS_NAME,
});
const clipPathId = Grid.RENDERING_AREA_CLIP_PATH_PREFIX + UtilityService.uuid();
// Asserting similar type to avoid refactoring all the grids
// TODO: Refactor lasagna service to accept multiple D3Selection types
// or refactor grid implementations/interfaces to maintain the same selection type
this.lasagna = new Lasagna(this.container, clipPathId);
this.renderingArea = this.buildRenderingArea(clipPathId);
this.adjustRenderingArea();
this.gridElementsLayer = this.lasagna.addLayer({
name: Grid.GRID_ELEMENTS_LAYER_NAME,
order: 100,
clipped: false,
});
const borders = this.buildBorders(this.gridElementsLayer);
if (borders) {
this.borders = borders;
}
return this;
}
/**
* Derived classes override this method to build the grid's plugins
*
* @param {IChart} chart The chart instance to pass to each plugin
*
* @returns {IChartPlugin[]} Default implementation returns an empty array
*/
buildPlugins(chart) {
return [];
}
/** See {@link IGrid#update} */
update() {
if (isEmpty(this.scales)) {
return this;
}
this.updateBorders();
this.adjustRenderingArea();
return this;
}
/** See {@link IGrid#updateDimensions} */
updateDimensions(dimensions) {
const dimensionConfig = this.config().dimension;
if (dimensions.width) {
dimensionConfig.outerWidth(dimensions.width - this.getOuterWidthDimensionCorrection());
}
if (dimensions.height) {
dimensionConfig.outerHeight(dimensions.height);
}
this.adjustRenderingArea();
this.updateRanges();
return this;
}
/** See {@link IGrid#updateRanges} */
updateRanges() {
this.update();
return this;
}
/**
* Calculate the width correction needed for accommodating grid elements that may extend beyond the chart's configured width
*/
getOuterWidthDimensionCorrection() {
return Grid.TICK_DIMENSION_CORRECTION;
}
/**
* Builds the grid borders as SVGElements based on the specified configuration
*
* @param {D3Selection} container d3 container for the borders
*
* @returns {Partial<IBorders>} The grid's borders
*/
buildBorders(container) {
if (!this.config() || !this.config().borders) {
return;
}
const borderConfigs = this.config().borders;
const borders = {};
const borderKeys = Object.keys(borderConfigs);
each(borderKeys, (side) => {
// We're creating even invisible borders and updating visibility afterwards
if (borderConfigs[side]) {
borders[side] =
this.createBorder(container, borderConfigs[side]) ??
undefined;
}
});
return borders;
}
/**
* Adjusts the grid's rendering area and clip path based on the grid's configured width and height
*/
adjustRenderingArea = () => {
const d = this.config().dimension;
const disableHeightCorrection = this.config().disableRenderAreaHeightCorrection;
const disableWidthCorrection = this.config().disableRenderAreaWidthCorrection;
const renderingAreaClipPathAttrs = {
width: Math.max(0, d.width()),
height: Math.max(0, d.height() +
(disableHeightCorrection
? 0
: Grid.RENDER_AREA_HEIGHT_CORRECTION)),
};
if (!disableHeightCorrection) {
renderingAreaClipPathAttrs["y"] =
-Grid.RENDER_AREA_HEIGHT_CORRECTION;
}
const renderingAreaAttrs = {
...renderingAreaClipPathAttrs,
// Width correction needed to prevent interaction gap between right side of grid and the edge of the rendering area
width: Math.max(0, d.width() -
(disableWidthCorrection
? 0
: Grid.RENDER_AREA_WIDTH_CORRECTION)),
};
this.renderingAreaClipPath.attrs(renderingAreaClipPathAttrs);
this.renderingArea.attrs(renderingAreaAttrs);
};
/**
* Builds the grid's rendering area as a layer on the lasagna
*
* @param {string} clipPathId The clip path identifier
*
* @returns {D3Selection} The grid's rendering area
*/
buildRenderingArea(clipPathId) {
this.renderingAreaClipPath = this._target
.append("clipPath")
.attr("id", clipPathId)
.append("rect");
const renderingAreaContainer = this.lasagna.addLayer({
name: Grid.RENDERING_AREA_LAYER_NAME,
order: -1,
clipped: true,
});
return renderingAreaContainer.append("rect").attrs({
"pointer-events": "all",
fill: "transparent",
});
}
/**
* Creates a border with the specified configuration in the provided container
*
* @param {D3Selection} container The container to append the border to
* @param {IBorderConfig} config The configuration to apply to the border
*
* @returns {SVGElement} The created border
*/
createBorder(container, config) {
const border = container
.append("line")
.attr("class", config.className || Grid.DEFAULT_BORDER_CLASS_NAME);
if (config.width) {
// use style instead of attr to override css style
border.style("stroke-width", config.width);
}
if (config.color) {
// use style instead of attr to override css style
border.style("stroke", config.color);
}
return border.node();
}
// TODO: borders are evil. reconsider!
// We're using borders instead of axis line and because of that we need to do these weird size adjustments
updateBottomBorder() {
if (!this.borders.bottom) {
throw new Error("BottomBorder is not defined");
}
select(this.borders.bottom)
.attrs({
x1: 0,
y1: this.config().dimension.height() - borderMidpoint,
x2: this.config().dimension.width() +
Grid.TICK_DIMENSION_CORRECTION,
y2: this.config().dimension.height() - borderMidpoint,
class: this._config.borders.bottom.className ||
Grid.DEFAULT_BORDER_CLASS_NAME,
})
.classed("hidden", !this._config.borders.bottom?.visible);
}
/**
* Updates the d3 line positioning and visibility attributes of each of the configured borders
*/
updateBorders() {
if (this.borders.bottom) {
this.updateBottomBorder();
}
if (this.borders.top) {
select(this.borders.top)
.attrs({
x1: 0,
y1: borderMidpoint,
x2: this.config().dimension.width() +
Grid.TICK_DIMENSION_CORRECTION,
y2: borderMidpoint,
})
.classed("hidden", !this._config.borders.top?.visible);
}
if (this.borders.right) {
select(this.borders.right)
.attrs({
x1: this.config().dimension.width() - borderMidpoint,
y1: 0,
x2: this.config().dimension.width() - borderMidpoint,
y2: this.config().dimension.height() +
Grid.TICK_DIMENSION_CORRECTION, // to get nice alignment with ticks
})
.classed("hidden", !this._config.borders.right?.visible);
}
if (this.borders.left) {
select(this.borders.left)
.attrs({
x1: borderMidpoint,
y1: 0,
x2: borderMidpoint,
y2: this.config().dimension.height() +
Grid.TICK_DIMENSION_CORRECTION, // to get nice alignment with ticks
})
.classed("hidden", !this._config.borders.left?.visible);
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.js","sourceRoot":"","sources":["../../../../src/core/grid/grid.ts"],"names":[],"mappings":"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","sourcesContent":["// © 2022 SolarWinds Worldwide, LLC. All rights reserved.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to\n//  deal in the Software without restriction, including without limitation the\n//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n//  sell copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n\nimport { select, Selection } from \"d3-selection\";\nimport each from \"lodash/each\";\nimport isEmpty from \"lodash/isEmpty\";\nimport { Subject } from \"rxjs\";\n\nimport { EventBus } from \"../common/event-bus\";\nimport { Lasagna } from \"../common/lasagna\";\nimport { ScalesIndex } from \"../common/scales/types\";\nimport { IChart, IChartEvent, IChartPlugin } from \"../common/types\";\nimport { D3Selection } from \"../common/types\";\nimport { UtilityService } from \"../common/utility.service\";\nimport { GridConfig } from \"./config/grid-config\";\nimport {\n    IAllAround,\n    IBorderConfig,\n    IBorders,\n    IDimensions,\n    IGrid,\n    IGridConfig,\n} from \"./types\";\n\nexport const borderMidpoint = 0.5;\n\ntype BorderKey = keyof IAllAround<IBorderConfig>;\n\n/**\n * @implements {IGrid}\n * Implementation for the dimensions, scaling, interactive area, and borders of a basic grid\n */\nexport abstract class Grid implements IGrid {\n    /** Class name for the grid */\n    public static GRID_CLASS_NAME = \"nui-chart-grid\";\n\n    /** Class name applied to each of the grid's borders by default */\n    public static DEFAULT_BORDER_CLASS_NAME = \"nui-chart-border\";\n\n    /** Prefix applied to the rendering area clip path id */\n    public static RENDERING_AREA_CLIP_PATH_PREFIX = \"clip-path_\";\n\n    /** Name for the lasagna layer containing the grid's rendered elements */\n    public static GRID_ELEMENTS_LAYER_NAME = \"grid-elements\";\n\n    /** Name for the rendering area lasagna layer */\n    public static RENDERING_AREA_LAYER_NAME = \"rendering-area\";\n\n    /** @ignore Height correction needed to prevent interaction gap between vertically stacked charts */\n    public static RENDER_AREA_HEIGHT_CORRECTION = 1;\n\n    /** @ignore Width correction needed to prevent interaction gap between right side of grid and the edge of the rendering area */\n    public static RENDER_AREA_WIDTH_CORRECTION = 1;\n\n    /** @ignore Width correction needed to sync bottom border length and grid width to tick placement */\n    public static TICK_DIMENSION_CORRECTION = 1;\n\n    /** Subject for indicating that the chart's dimensions should be updated */\n    public updateChartDimensionsSubject: Subject<void>;\n\n    /** Event bus provided by the chart */\n    public eventBus: EventBus<IChartEvent>;\n\n    /** d3 container for the grid */\n    protected container: D3Selection<SVGGElement>;\n\n    /** d3 selection for the grid's rendering area clip path */\n    protected renderingAreaClipPath: D3Selection<SVGRectElement>;\n\n    /** d3 selection for the grid's rendering area */\n    protected renderingArea: D3Selection<SVGRectElement>;\n\n    /** d3 selection for the grid's interactive area */\n    protected interactiveArea: D3Selection<SVGRectElement>;\n\n    /** The grid's layer manager */\n    protected lasagna: Lasagna;\n\n    /** Lasagna layer for the grid's rendered elements */\n    protected gridElementsLayer: Selection<SVGElement, any, SVGElement, any>;\n\n    /** Definition of the grid's borders as rendered */\n    protected borders: Partial<IBorders> = {};\n\n    /** Property value of the grid's scales */\n    protected _scales: ScalesIndex;\n\n    /** Property value of the grid's configuration */\n    protected _config: IGridConfig;\n\n    /** Property value of the grid's target d3 selection */\n    protected _target: D3Selection<SVGSVGElement>;\n\n    /** See {@link IGrid#getInteractiveArea} */\n    public getInteractiveArea(): D3Selection<SVGRectElement> {\n        return this.interactiveArea;\n    }\n\n    /** See {@link IGrid#getLasagna} */\n    public getLasagna(): Lasagna {\n        return this.lasagna;\n    }\n\n    /** @ignore */\n    public set scales(scales: ScalesIndex) {\n        this._scales = scales;\n    }\n\n    /** @ignore */\n    public get scales(): ScalesIndex {\n        return this._scales;\n    }\n\n    /** See {@link IGrid#config} */\n    public config(): IGridConfig;\n    /** See {@link IGrid#config} */\n    public config(config: IGridConfig): this;\n    /** See {@link IGrid#config} */\n    public config(config?: IGridConfig): IGridConfig | this {\n        if (config === undefined) {\n            return this._config;\n        }\n        this._config = config;\n        return this;\n    }\n\n    /** See {@link IGrid#target} */\n    public target(): D3Selection<SVGSVGElement>;\n    /** See {@link IGrid#target} */\n    public target(target: D3Selection<SVGSVGElement>): IGrid;\n    /** See {@link IGrid#target} */\n    public target(\n        target?: D3Selection<SVGSVGElement>\n    ): D3Selection<SVGSVGElement> | IGrid {\n        if (target === undefined) {\n            return this._target;\n        }\n        this._target = target;\n        return this;\n    }\n\n    /** See {@link IGrid#build} */\n    public build(): IGrid {\n        if (!this.config()) {\n            const config = new GridConfig();\n            this.config(config);\n        }\n\n        this.container = this._target.append(\"g\").attrs({\n            class: Grid.GRID_CLASS_NAME,\n        });\n\n        const clipPathId =\n            Grid.RENDERING_AREA_CLIP_PATH_PREFIX + UtilityService.uuid();\n        // Asserting similar type to avoid refactoring all the grids\n        // TODO: Refactor lasagna service to accept multiple D3Selection types\n        //  or refactor grid implementations/interfaces to maintain the same selection type\n        this.lasagna = new Lasagna(\n            <D3Selection<SVGSVGElement>>(<unknown>this.container),\n            clipPathId\n        );\n        this.renderingArea = this.buildRenderingArea(clipPathId);\n        this.adjustRenderingArea();\n\n        this.gridElementsLayer = this.lasagna.addLayer({\n            name: Grid.GRID_ELEMENTS_LAYER_NAME,\n            order: 100,\n            clipped: false,\n        });\n\n        const borders = this.buildBorders(this.gridElementsLayer);\n        if (borders) {\n            this.borders = borders;\n        }\n\n        return this;\n    }\n\n    /**\n     * Derived classes override this method to build the grid's plugins\n     *\n     * @param {IChart} chart The chart instance to pass to each plugin\n     *\n     * @returns {IChartPlugin[]} Default implementation returns an empty array\n     */\n    public buildPlugins(chart: IChart): IChartPlugin[] {\n        return [];\n    }\n\n    /** See {@link IGrid#update} */\n    public update(): IGrid {\n        if (isEmpty(this.scales)) {\n            return this;\n        }\n\n        this.updateBorders();\n        this.adjustRenderingArea();\n        return this;\n    }\n\n    /** See {@link IGrid#updateDimensions} */\n    public updateDimensions(dimensions: Partial<IDimensions>): IGrid {\n        const dimensionConfig = this.config().dimension;\n\n        if (dimensions.width) {\n            dimensionConfig.outerWidth(\n                dimensions.width - this.getOuterWidthDimensionCorrection()\n            );\n        }\n        if (dimensions.height) {\n            dimensionConfig.outerHeight(dimensions.height);\n        }\n\n        this.adjustRenderingArea();\n        this.updateRanges();\n\n        return this;\n    }\n    /** See {@link IGrid#updateRanges} */\n    public updateRanges(): IGrid {\n        this.update();\n        return this;\n    }\n\n    /**\n     * Calculate the width correction needed for accommodating grid elements that may extend beyond the chart's configured width\n     */\n    protected getOuterWidthDimensionCorrection(): number {\n        return Grid.TICK_DIMENSION_CORRECTION;\n    }\n\n    /**\n     * Builds the grid borders as SVGElements based on the specified configuration\n     *\n     * @param {D3Selection} container d3 container for the borders\n     *\n     * @returns {Partial<IBorders>} The grid's borders\n     */\n    protected buildBorders(\n        container: D3Selection\n    ): Partial<IBorders> | undefined {\n        if (!this.config() || !this.config().borders) {\n            return;\n        }\n\n        const borderConfigs = this.config().borders;\n        const borders: Partial<IBorders> = {};\n        const borderKeys = <BorderKey[]>Object.keys(borderConfigs);\n        each(borderKeys, (side: BorderKey) => {\n            // We're creating even invisible borders and updating visibility afterwards\n            if (borderConfigs[side]) {\n                borders[side] =\n                    this.createBorder(container, borderConfigs[side]) ??\n                    undefined;\n            }\n        });\n\n        return borders;\n    }\n\n    /**\n     * Adjusts the grid's rendering area and clip path based on the grid's configured width and height\n     */\n    protected adjustRenderingArea = (): void => {\n        const d = this.config().dimension;\n        const disableHeightCorrection =\n            this.config().disableRenderAreaHeightCorrection;\n        const disableWidthCorrection =\n            this.config().disableRenderAreaWidthCorrection;\n\n        const renderingAreaClipPathAttrs = {\n            width: Math.max(0, d.width()),\n            height: Math.max(\n                0,\n                d.height() +\n                    (disableHeightCorrection\n                        ? 0\n                        : Grid.RENDER_AREA_HEIGHT_CORRECTION)\n            ),\n        } as any;\n\n        if (!disableHeightCorrection) {\n            renderingAreaClipPathAttrs[\"y\"] =\n                -Grid.RENDER_AREA_HEIGHT_CORRECTION;\n        }\n\n        const renderingAreaAttrs = {\n            ...renderingAreaClipPathAttrs,\n            // Width correction needed to prevent interaction gap between right side of grid and the edge of the rendering area\n            width: Math.max(\n                0,\n                d.width() -\n                    (disableWidthCorrection\n                        ? 0\n                        : Grid.RENDER_AREA_WIDTH_CORRECTION)\n            ),\n        };\n\n        this.renderingAreaClipPath.attrs(renderingAreaClipPathAttrs);\n        this.renderingArea.attrs(renderingAreaAttrs);\n    };\n\n    /**\n     * Builds the grid's rendering area as a layer on the lasagna\n     *\n     * @param {string} clipPathId The clip path identifier\n     *\n     * @returns {D3Selection} The grid's rendering area\n     */\n    private buildRenderingArea(\n        clipPathId: string\n    ): D3Selection<SVGRectElement> {\n        this.renderingAreaClipPath = this._target\n            .append(\"clipPath\")\n            .attr(\"id\", clipPathId)\n            .append(\"rect\");\n\n        const renderingAreaContainer = this.lasagna.addLayer({\n            name: Grid.RENDERING_AREA_LAYER_NAME,\n            order: -1,\n            clipped: true,\n        });\n        return renderingAreaContainer.append(\"rect\").attrs({\n            \"pointer-events\": \"all\",\n            fill: \"transparent\",\n        });\n    }\n\n    /**\n     * Creates a border with the specified configuration in the provided container\n     *\n     * @param {D3Selection} container The container to append the border to\n     * @param {IBorderConfig} config The configuration to apply to the border\n     *\n     * @returns {SVGElement} The created border\n     */\n    private createBorder(\n        container: D3Selection,\n        config: IBorderConfig\n    ): SVGElement | null {\n        const border = container\n            .append(\"line\")\n            .attr(\"class\", config.className || Grid.DEFAULT_BORDER_CLASS_NAME);\n\n        if (config.width) {\n            // use style instead of attr to override css style\n            border.style(\"stroke-width\", config.width);\n        }\n        if (config.color) {\n            // use style instead of attr to override css style\n            border.style(\"stroke\", config.color);\n        }\n\n        return border.node();\n    }\n\n    // TODO: borders are evil. reconsider!\n    // We're using borders instead of axis line and because of that we need to do these weird size adjustments\n    protected updateBottomBorder(): void {\n        if (!this.borders.bottom) {\n            throw new Error(\"BottomBorder is not defined\");\n        }\n        select(this.borders.bottom)\n            .attrs({\n                x1: 0,\n                y1: this.config().dimension.height() - borderMidpoint,\n                x2:\n                    this.config().dimension.width() +\n                    Grid.TICK_DIMENSION_CORRECTION, // to get nice alignment with ticks\n                y2: this.config().dimension.height() - borderMidpoint,\n                class:\n                    this._config.borders.bottom.className ||\n                    Grid.DEFAULT_BORDER_CLASS_NAME,\n            })\n            .classed(\"hidden\", !this._config.borders.bottom?.visible);\n    }\n\n    /**\n     * Updates the d3 line positioning and visibility attributes of each of the configured borders\n     */\n    protected updateBorders(): void {\n        if (this.borders.bottom) {\n            this.updateBottomBorder();\n        }\n        if (this.borders.top) {\n            select(this.borders.top)\n                .attrs({\n                    x1: 0,\n                    y1: borderMidpoint, // the line was outside of the viewport in some browser when set to 0\n                    x2:\n                        this.config().dimension.width() +\n                        Grid.TICK_DIMENSION_CORRECTION, // to get nice alignment with ticks\n                    y2: borderMidpoint,\n                })\n                .classed(\"hidden\", !this._config.borders.top?.visible);\n        }\n        if (this.borders.right) {\n            select(this.borders.right)\n                .attrs({\n                    x1: this.config().dimension.width() - borderMidpoint,\n                    y1: 0,\n                    x2: this.config().dimension.width() - borderMidpoint,\n                    y2:\n                        this.config().dimension.height() +\n                        Grid.TICK_DIMENSION_CORRECTION, // to get nice alignment with ticks\n                })\n                .classed(\"hidden\", !this._config.borders.right?.visible);\n        }\n        if (this.borders.left) {\n            select(this.borders.left)\n                .attrs({\n                    x1: borderMidpoint,\n                    y1: 0,\n                    x2: borderMidpoint,\n                    y2:\n                        this.config().dimension.height() +\n                        Grid.TICK_DIMENSION_CORRECTION, // to get nice alignment with ticks\n                })\n                .classed(\"hidden\", !this._config.borders.left?.visible);\n        }\n    }\n}\n"]}