@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
185 lines • 26.3 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 { extent } from "d3";
import defaultsDeep from "lodash/defaultsDeep";
import each from "lodash/each";
import get from "lodash/get";
import { DATA_POINT_NOT_FOUND, STANDARD_RENDER_LAYERS } from "../../constants";
import { EMPTY_CONTINUOUS_DOMAIN } from "./scales/types";
import { RenderLayerName, RenderState, } from "../../renderers/types";
/**
* The abstract base class for chart renderers with some limited default functionality
*/
// For why the "dynamic" decorator is used see https://github.com/ng-packagr/ng-packagr/issues/641
// @dynamic
export class Renderer {
config;
static DEFAULT_CONFIG = {
stateStyles: {
[RenderState.default]: {
opacity: 1,
},
[RenderState.hidden]: {
opacity: 0,
},
[RenderState.deemphasized]: {
opacity: 0.1,
},
[RenderState.emphasized]: {
opacity: 1,
},
},
};
constructor(config = {}) {
this.config = config;
// setting default values to the properties that were not set by user
this.config = defaultsDeep(this.config, Renderer.DEFAULT_CONFIG);
}
interaction = {};
/**
* Based on provided values, return the nearest data point that the given coordinates represent. This is used for mouse hover behavior
*
* @param {IDataSeries} series series from which to determine the index corresponding to the specified values
* @param {{ [axis: string]: any }} values the values from which a data point index can be determined
* @param {Scales} scales the scales to be used in the index calculation
*
* @returns {number} negative value means that index is not found
*/
getDataPointIndex(series, values, scales) {
return DATA_POINT_NOT_FOUND;
}
/**
* Highlight the data point corresponding to the specified data point index
*
* @param {IRenderSeries} renderSeries The series on which to render the data point highlight
* @param {number} dataPointIndex index of the highlighted point within the data series (pass -1 to remove the highlight marker)
* @param {Subject<IRendererEventPayload>} rendererSubject A subject to optionally invoke for emitting events regarding a data point
*/
highlightDataPoint(renderSeries, dataPointIndex, rendererSubject) { }
/**
* Get the style attributes for the specified state that we need to apply to a series container
*
* @param {RenderState} state the state for which to retrieve container styles
*
* @returns {ValueMap<any, any>} the container styles for the specified state
*/
getContainerStateStyles = (state) => {
if (!this.config.stateStyles) {
throw new Error("stateStyles property is not defined");
}
return this.config.stateStyles[state || RenderState.default];
};
/**
* Set the RenderState of the target data series
*
* @param {IRenderContainers} renderContainers the render containers of the series
* @param {RenderState} state The new state for the target series
*/
setSeriesState(renderContainers, state) { }
/**
* Set the RenderState of the target data point
*
* @param {D3Selection} target the target data point
* @param {RenderState} state The new state for the target data point
*/
setDataPointState(target, state) { }
/**
* Calculate domain for data filtered by given filterScales
*
* @param dataSeries
* @param filterScales
* @param scaleKey
* @param scale
* @returns array of datapoints from <code>dataSeries</code> filtered by domains of given <code>filterScale</code>s
*/
getDomainOfFilteredData(dataSeries, filterScales, scaleKey, scale) {
let filteredData = dataSeries.data;
for (const fixedScaleKey of Object.keys(filterScales)) {
const filterScale = filterScales[fixedScaleKey];
if (!filterScale.isDomainFixed || !filterScale.isContinuous()) {
continue;
}
filteredData = this.filterDataByDomain(filteredData, dataSeries, fixedScaleKey, filterScale.domain());
}
return this.getDomain(filteredData, dataSeries, scaleKey, scale);
}
/**
* Calculate the domain using the data of a series
*
* @param {any[]} data source data, can be filtered
* @param dataSeries related data series
* @param {string} scaleName name of the scale for which domain calculation is needed
* @param scale
*
* @returns {[any, any]} min and max values as an array
*/
getDomain(data, dataSeries, scaleName, scale) {
if (!data || data.length === 0) {
return EMPTY_CONTINUOUS_DOMAIN;
}
return extent(data, (datum, index, arr) => dataSeries.accessors.data?.[scaleName]?.(datum, index, Array.from(arr), dataSeries));
}
/**
* Filters given dataset by domain of provided scale
*
* @param data
* @param dataSeries
* @param scaleName
* @param domain
*/
filterDataByDomain(data, dataSeries, scaleName, domain) {
const accessor = dataSeries.accessors.data?.[scaleName];
// if (isNil(accessor)) {
// throw new Error("accessor is not defined");
// }
return data.filter((d, i) => {
// @ts-ignore
const value = accessor(d, i, data, dataSeries);
return value >= domain[0] && value <= domain[1];
});
}
/**
* Get the definitions of lasagna layers required for visualizing data
*
* @returns {ILasagnaLayer[]} lasagna layer definitions
*/
getRequiredLayers() {
return [STANDARD_RENDER_LAYERS[RenderLayerName.data]];
}
setupInteraction(path, nativeEvent, target, dataPointSubject, dataPoint) {
const eventList = get(this.interaction, path, {})[nativeEvent];
if (!eventList) {
return;
}
each(eventList, (targetEvent) => {
target.on(nativeEvent, () => {
const bbox = target.node().getBoundingClientRect();
dataPointSubject.next({
eventName: targetEvent,
data: {
...dataPoint,
position: bbox,
},
});
});
});
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../../../src/core/common/renderer.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 { extent, Numeric } from \"d3\";\nimport { Selection } from \"d3-selection\";\nimport { ValueMap } from \"d3-selection-multi\";\nimport defaultsDeep from \"lodash/defaultsDeep\";\nimport each from \"lodash/each\";\nimport get from \"lodash/get\";\nimport { Subject } from \"rxjs\";\n\nimport { DATA_POINT_NOT_FOUND, STANDARD_RENDER_LAYERS } from \"../../constants\";\nimport { EMPTY_CONTINUOUS_DOMAIN, IScale, Scales } from \"./scales/types\";\nimport {\n    D3Selection,\n    IAccessors,\n    IDataPoint,\n    IDataSeries,\n    ILasagnaLayer,\n    IPosition,\n    IRenderContainers,\n    IRendererConfig,\n    IRendererEventPayload,\n} from \"./types\";\nimport {\n    IRenderSeries,\n    RenderLayerName,\n    RenderState,\n} from \"../../renderers/types\";\n\n/**\n * The abstract base class for chart renderers with some limited default functionality\n */\n// For why the \"dynamic\" decorator is used see https://github.com/ng-packagr/ng-packagr/issues/641\n// @dynamic\nexport abstract class Renderer<TA extends IAccessors> {\n    public static readonly DEFAULT_CONFIG: IRendererConfig = {\n        stateStyles: {\n            [RenderState.default]: {\n                opacity: 1,\n            },\n            [RenderState.hidden]: {\n                opacity: 0,\n            },\n            [RenderState.deemphasized]: {\n                opacity: 0.1,\n            },\n            [RenderState.emphasized]: {\n                opacity: 1,\n            },\n        },\n    };\n\n    constructor(public config: IRendererConfig = {}) {\n        // setting default values to the properties that were not set by user\n        this.config = defaultsDeep(this.config, Renderer.DEFAULT_CONFIG);\n    }\n\n    public interaction: Record<string, any> = {};\n\n    /**\n     * Draw the visual representation of the provided data series\n     *\n     * @param {IRenderSeries} renderSeries The series to render\n     * @param {Subject<IRendererEventPayload>} rendererSubject A subject to optionally invoke for emitting events regarding a data point\n     */\n    public abstract draw(\n        renderSeries: IRenderSeries<TA>,\n        rendererSubject: Subject<IRendererEventPayload>\n    ): void;\n\n    /**\n     * Return position of a specified datapoint\n     *\n     * @param {IDataSeries} dataSeries\n     * @param {number} index\n     * @param {Scales} scales\n     * @returns {IPosition}\n     */\n    public abstract getDataPointPosition(\n        dataSeries: IDataSeries<TA>,\n        index: number,\n        scales: Scales\n    ): IPosition | undefined;\n\n    /**\n     * Based on provided values, return the nearest data point that the given coordinates represent. This is used for mouse hover behavior\n     *\n     * @param {IDataSeries} series series from which to determine the index corresponding to the specified values\n     * @param {{ [axis: string]: any }} values the values from which a data point index can be determined\n     * @param {Scales} scales the scales to be used in the index calculation\n     *\n     * @returns {number} negative value means that index is not found\n     */\n    public getDataPointIndex(\n        series: IDataSeries<TA>,\n        values: { [axis: string]: any },\n        scales: Scales\n    ): number {\n        return DATA_POINT_NOT_FOUND;\n    }\n\n    /**\n     * Highlight the data point corresponding to the specified data point index\n     *\n     * @param {IRenderSeries} renderSeries The series on which to render the data point highlight\n     * @param {number} dataPointIndex index of the highlighted point within the data series (pass -1 to remove the highlight marker)\n     * @param {Subject<IRendererEventPayload>} rendererSubject A subject to optionally invoke for emitting events regarding a data point\n     */\n    public highlightDataPoint(\n        renderSeries: IRenderSeries<TA>,\n        dataPointIndex: number,\n        rendererSubject: Subject<IRendererEventPayload>\n    ): void {}\n\n    /**\n     * Get the style attributes for the specified state that we need to apply to a series container\n     *\n     * @param {RenderState} state the state for which to retrieve container styles\n     *\n     * @returns {ValueMap<any, any>} the container styles for the specified state\n     */\n    public getContainerStateStyles = (\n        state: RenderState\n    ): ValueMap<any, any> => {\n        if (!this.config.stateStyles) {\n            throw new Error(\"stateStyles property is not defined\");\n        }\n        return this.config.stateStyles[state || RenderState.default];\n    };\n\n    /**\n     * Set the RenderState of the target data series\n     *\n     * @param {IRenderContainers} renderContainers the render containers of the series\n     * @param {RenderState} state The new state for the target series\n     */\n    public setSeriesState(\n        renderContainers: IRenderContainers,\n        state: RenderState\n    ): void {}\n\n    /**\n     * Set the RenderState of the target data point\n     *\n     * @param {D3Selection} target the target data point\n     * @param {RenderState} state The new state for the target data point\n     */\n    public setDataPointState(target: D3Selection, state: RenderState): void {}\n\n    /**\n     * Calculate domain for data filtered by given filterScales\n     *\n     * @param dataSeries\n     * @param filterScales\n     * @param scaleKey\n     * @param scale\n     * @returns array of datapoints from <code>dataSeries</code> filtered by domains of given <code>filterScale</code>s\n     */\n    public getDomainOfFilteredData(\n        dataSeries: IDataSeries<TA>,\n        filterScales: Record<string, IScale<any>>,\n        scaleKey: string,\n        scale: IScale<any>\n    ): any[] {\n        let filteredData = dataSeries.data;\n        for (const fixedScaleKey of Object.keys(filterScales)) {\n            const filterScale = filterScales[fixedScaleKey];\n            if (!filterScale.isDomainFixed || !filterScale.isContinuous()) {\n                continue;\n            }\n\n            filteredData = this.filterDataByDomain(\n                filteredData,\n                dataSeries,\n                fixedScaleKey,\n                filterScale.domain()\n            );\n        }\n\n        return this.getDomain(filteredData, dataSeries, scaleKey, scale);\n    }\n\n    /**\n     * Calculate the domain using the data of a series\n     *\n     * @param {any[]} data source data, can be filtered\n     * @param dataSeries related data series\n     * @param {string} scaleName name of the scale for which domain calculation is needed\n     * @param scale\n     *\n     * @returns {[any, any]} min and max values as an array\n     */\n    public getDomain(\n        data: any[],\n        dataSeries: IDataSeries<TA>,\n        scaleName: string,\n        scale: IScale<any>\n    ): any[] {\n        if (!data || data.length === 0) {\n            return EMPTY_CONTINUOUS_DOMAIN;\n        }\n\n        return extent<Numeric, Numeric>(data, (datum, index, arr) =>\n            dataSeries.accessors.data?.[scaleName]?.(\n                datum,\n                index,\n                Array.from(arr),\n                dataSeries\n            )\n        );\n    }\n\n    /**\n     * Filters given dataset by domain of provided scale\n     *\n     * @param data\n     * @param dataSeries\n     * @param scaleName\n     * @param domain\n     */\n    public filterDataByDomain(\n        data: any[],\n        dataSeries: IDataSeries<TA>,\n        scaleName: string,\n        domain: any[]\n    ): any[] {\n        const accessor = dataSeries.accessors.data?.[scaleName];\n\n        // if (isNil(accessor)) {\n        //     throw new Error(\"accessor is not defined\");\n        // }\n\n        return data.filter((d, i) => {\n            // @ts-ignore\n            const value = accessor(d, i, data, dataSeries);\n            return value >= domain[0] && value <= domain[1];\n        });\n    }\n\n    /**\n     * Get the definitions of lasagna layers required for visualizing data\n     *\n     * @returns {ILasagnaLayer[]} lasagna layer definitions\n     */\n    public getRequiredLayers(): ILasagnaLayer[] {\n        return [STANDARD_RENDER_LAYERS[RenderLayerName.data]];\n    }\n\n    protected setupInteraction(\n        path: string[],\n        nativeEvent: string,\n        target: Selection<any, any, any, any>,\n        dataPointSubject: Subject<IRendererEventPayload>,\n        dataPoint: Partial<IDataPoint>\n    ): void {\n        const eventList: string[] = get(this.interaction, path, {})[\n            nativeEvent\n        ];\n        if (!eventList) {\n            return;\n        }\n\n        each(eventList, (targetEvent: string) => {\n            target.on(nativeEvent, () => {\n                const bbox = target.node().getBoundingClientRect();\n                dataPointSubject.next({\n                    eventName: targetEvent,\n                    data: <IDataPoint>{\n                        ...dataPoint,\n                        position: bbox,\n                    },\n                });\n            });\n        });\n    }\n}\n"]}