vccs 0.6.0 → 1.0.0-beta.2

package/dist/es/state/selectors/radialBarSelectors.mjs

@@ -1,259 +0,0 @@
-import { isCategoricalAxis, isNullish } from "../../utils/validate.mjs";
-import { selectChartDataAndAlwaysIgnoreIndexes, selectChartDataWithIndexes } from "./dataSelectors.mjs";
-import { mathSign } from "../../utils/data.mjs";
-import { selectBarCategoryGap, selectBarGap, selectRootBarSize, selectRootMaxBarSize, selectStackOffsetType } from "./rootPropsSelectors.mjs";
-import { selectChartLayout } from "./common.mjs";
-import { selectAngleAxis, selectPolarViewBox, selectRadiusAxis } from "./polarAxisSelectors.mjs";
-import { getBandSizeOfAxis, getBaseValueOfBar, getCateCoordinateOfBar, getValueByDataKey, truncateByDomain } from "../../utils/chart.mjs";
-import { combineStackGroups } from "./axisSelectors.mjs";
-import { combineAllBarPositions, combineBarSizeList, combineStackedData } from "./barSelectors.mjs";
-import { selectPolarDisplayedData, selectPolarItemsSettings, selectUnfilteredPolarItems } from "./polarSelectors.mjs";
-import { selectPolarAxisScale, selectPolarAxisTicks, selectPolarGraphicalItemAxisTicks } from "./polarScaleSelectors.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/radialBarSelectors.ts
-function selectRadiusAxisForRadialBar(state, radiusAxisId) {
-	return selectRadiusAxis(state, radiusAxisId);
-}
-function selectRadiusAxisScaleForRadar(state, radiusAxisId) {
-	return selectPolarAxisScale(state, "radiusAxis", radiusAxisId);
-}
-var selectRadiusAxisWithScale = createSelector([selectRadiusAxisForRadialBar, selectRadiusAxisScaleForRadar], (axis, scale) => {
-	if (axis == null || scale == null) return;
-	return {
-		...axis,
-		scale
-	};
-});
-function selectRadiusAxisTicks(state, radiusAxisId, _angleAxisId, isPanorama) {
-	return selectPolarGraphicalItemAxisTicks(state, "radiusAxis", radiusAxisId, isPanorama);
-}
-function selectAngleAxisForRadialBar(state, _radiusAxisId, angleAxisId) {
-	return selectAngleAxis(state, angleAxisId);
-}
-function selectAngleAxisScaleForRadialBar(state, _radiusAxisId, angleAxisId) {
-	return selectPolarAxisScale(state, "angleAxis", angleAxisId);
-}
-var selectAngleAxisWithScale = createSelector([selectAngleAxisForRadialBar, selectAngleAxisScaleForRadialBar], (axis, scale) => {
-	if (axis == null || scale == null) return;
-	return {
-		...axis,
-		scale
-	};
-});
-function selectAngleAxisTicks(state, _radiusAxisId, angleAxisId, isPanorama) {
-	return selectPolarAxisTicks(state, "angleAxis", angleAxisId, isPanorama);
-}
-function pickRadialBarSettings(_state, _radiusAxisId, _angleAxisId, radialBarSettings) {
-	return radialBarSettings;
-}
-var selectSynchronisedRadialBarSettings = createSelector([selectUnfilteredPolarItems, pickRadialBarSettings], (graphicalItems, radialBarSettingsFromProps) => {
-	if (graphicalItems.some((pgis) => pgis.type === "radialBar" && radialBarSettingsFromProps.dataKey === pgis.dataKey && radialBarSettingsFromProps.stackId === pgis.stackId)) return radialBarSettingsFromProps;
-});
-var selectBandSizeOfPolarAxis = createSelector([
-	selectChartLayout,
-	selectRadiusAxisWithScale,
-	selectRadiusAxisTicks,
-	selectAngleAxisWithScale,
-	selectAngleAxisTicks
-], (layout, radiusAxis, radiusAxisTicks, angleAxis, angleAxisTicks) => {
-	if (isCategoricalAxis(layout, "radiusAxis")) return getBandSizeOfAxis(radiusAxis, radiusAxisTicks, false);
-	return getBandSizeOfAxis(angleAxis, angleAxisTicks, false);
-});
-var selectBaseValue = createSelector([
-	selectAngleAxisWithScale,
-	selectRadiusAxisWithScale,
-	selectChartLayout
-], (angleAxis, radiusAxis, layout) => {
-	const numericAxis = layout === "radial" ? angleAxis : radiusAxis;
-	if (numericAxis == null || numericAxis.scale == null) return;
-	return getBaseValueOfBar({ numericAxis });
-});
-function pickAngleAxisId(_state, _radiusAxisId, angleAxisId, _radialBarSettings) {
-	return angleAxisId;
-}
-function pickRadiusAxisId(_state, radiusAxisId, _angleAxisId, _radialBarSettings) {
-	return radiusAxisId;
-}
-function pickMaxBarSize(_state, _radiusAxisId, _angleAxisId, radialBarSettings) {
-	return radialBarSettings.maxBarSize;
-}
-var selectAllVisibleRadialBars = createSelector([
-	selectChartLayout,
-	selectUnfilteredPolarItems,
-	pickAngleAxisId,
-	pickRadiusAxisId
-], (layout, allItems, angleAxisId, radiusAxisId) => {
-	return allItems.filter((i) => {
-		if (layout === "centric") return i.angleAxisId === angleAxisId;
-		return i.radiusAxisId === radiusAxisId;
-	}).filter((i) => i.hide === false).filter((i) => i.type === "radialBar");
-});
-/**
-* The generator never returned the totalSize which means that barSize in polar chart can not support percent values.
-* We can add that if we want to I suppose.
-* @returns undefined - but it should be a total size of numerical axis in polar chart
-*/
-var selectPolarBarAxisSize = () => void 0;
-var selectPolarBarPosition = createSelector([createSelector([
-	createSelector([
-		selectAllVisibleRadialBars,
-		selectRootBarSize,
-		selectPolarBarAxisSize
-	], combineBarSizeList),
-	selectRootMaxBarSize,
-	selectBarGap,
-	selectBarCategoryGap,
-	createSelector([
-		selectChartLayout,
-		selectRootMaxBarSize,
-		selectAngleAxisWithScale,
-		selectAngleAxisTicks,
-		selectRadiusAxisWithScale,
-		selectRadiusAxisTicks,
-		pickMaxBarSize
-	], (layout, globalMaxBarSize, angleAxis, angleAxisTicks, radiusAxis, radiusAxisTicks, childMaxBarSize) => {
-		const maxBarSize = isNullish(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize;
-		if (layout === "centric") return getBandSizeOfAxis(angleAxis, angleAxisTicks, true) ?? maxBarSize ?? 0;
-		return getBandSizeOfAxis(radiusAxis, radiusAxisTicks, true) ?? maxBarSize ?? 0;
-	}),
-	selectBandSizeOfPolarAxis,
-	pickMaxBarSize
-], combineAllBarPositions), selectSynchronisedRadialBarSettings], (allBarPositions, barSettings) => {
-	if (allBarPositions == null || barSettings == null) return;
-	const position = allBarPositions.find((p) => p.stackId === barSettings.stackId && p.dataKeys.includes(barSettings.dataKey));
-	if (position == null) return;
-	return position.position;
-});
-var selectStackGroups = createSelector([
-	selectPolarDisplayedData,
-	selectPolarItemsSettings,
-	selectStackOffsetType
-], combineStackGroups);
-var selectRadialBarStackGroups = (state, radiusAxisId, angleAxisId) => {
-	if (selectChartLayout(state) === "centric") return selectStackGroups(state, "radiusAxis", radiusAxisId);
-	return selectStackGroups(state, "angleAxis", angleAxisId);
-};
-var selectPolarStackedData = createSelector([selectRadialBarStackGroups, selectSynchronisedRadialBarSettings], combineStackedData);
-function computeRadialBarDataItems({ displayedData, stackedData, dataStartIndex, stackedDomain, dataKey, baseValue, layout, radiusAxis, radiusAxisTicks, bandSize, pos, angleAxis, minPointSize, cx, cy, angleAxisTicks, startAngle: rootStartAngle, endAngle: rootEndAngle }) {
-	return (displayedData ?? []).map((entry, index) => {
-		let value, innerRadius, outerRadius, startAngle, endAngle, backgroundSector;
-		if (stackedData) value = truncateByDomain(stackedData[dataStartIndex + index], stackedDomain);
-		else {
-			value = getValueByDataKey(entry, dataKey);
-			if (!Array.isArray(value)) value = [baseValue, value];
-		}
-		if (layout === "radial") {
-			startAngle = angleAxis.scale(value[0]) ?? rootStartAngle;
-			endAngle = angleAxis.scale(value[1]) ?? rootEndAngle;
-			innerRadius = getCateCoordinateOfBar({
-				axis: radiusAxis,
-				ticks: radiusAxisTicks,
-				bandSize,
-				offset: pos.offset,
-				entry,
-				index
-			});
-			if (innerRadius != null) innerRadius = innerRadius - bandSize / 2;
-			if (innerRadius != null && endAngle != null && startAngle != null) {
-				outerRadius = innerRadius + pos.size;
-				const deltaAngle = endAngle - startAngle;
-				if (Math.abs(minPointSize) > 0 && Math.abs(deltaAngle) < Math.abs(minPointSize)) {
-					const delta = mathSign(deltaAngle || minPointSize) * (Math.abs(minPointSize) - Math.abs(deltaAngle));
-					endAngle += delta;
-				}
-				backgroundSector = { background: {
-					cx,
-					cy,
-					innerRadius,
-					outerRadius,
-					startAngle: rootStartAngle,
-					endAngle: rootEndAngle
-				} };
-			}
-		} else {
-			innerRadius = radiusAxis.scale(value[0]);
-			outerRadius = radiusAxis.scale(value[1]);
-			startAngle = getCateCoordinateOfBar({
-				axis: angleAxis,
-				ticks: angleAxisTicks,
-				bandSize,
-				offset: pos.offset,
-				entry,
-				index
-			});
-			if (innerRadius != null && outerRadius != null && startAngle != null) {
-				endAngle = startAngle + pos.size;
-				const deltaRadius = outerRadius - innerRadius;
-				if (Math.abs(minPointSize) > 0 && Math.abs(deltaRadius) < Math.abs(minPointSize)) {
-					const delta = mathSign(deltaRadius || minPointSize) * (Math.abs(minPointSize) - Math.abs(deltaRadius));
-					outerRadius += delta;
-				}
-			}
-		}
-		return {
-			...entry,
-			...backgroundSector,
-			payload: entry,
-			value: stackedData ? value : value[1],
-			cx,
-			cy,
-			innerRadius,
-			outerRadius,
-			startAngle,
-			endAngle
-		};
-	});
-}
-var selectRadialBarSectors = createSelector([
-	selectAngleAxisWithScale,
-	selectAngleAxisTicks,
-	selectRadiusAxisWithScale,
-	selectRadiusAxisTicks,
-	selectChartDataWithIndexes,
-	selectSynchronisedRadialBarSettings,
-	selectBandSizeOfPolarAxis,
-	selectChartLayout,
-	selectBaseValue,
-	selectPolarViewBox,
-	selectPolarBarPosition,
-	selectPolarStackedData
-], (angleAxis, angleAxisTicks, radiusAxis, radiusAxisTicks, { chartData, dataStartIndex, dataEndIndex }, radialBarSettings, bandSize, layout, baseValue, polarViewBox, pos, stackedData) => {
-	if (radialBarSettings == null || radiusAxis == null || angleAxis == null || chartData == null || bandSize == null || pos == null || polarViewBox == null || angleAxisTicks == null || radiusAxisTicks == null || layout !== "centric" && layout !== "radial") return;
-	const { dataKey, minPointSize } = radialBarSettings;
-	const { cx, cy, startAngle, endAngle } = polarViewBox;
-	return computeRadialBarDataItems({
-		angleAxis,
-		angleAxisTicks,
-		bandSize,
-		baseValue,
-		cx,
-		cy,
-		dataKey,
-		dataStartIndex,
-		displayedData: chartData.slice(dataStartIndex, dataEndIndex + 1),
-		endAngle,
-		layout,
-		minPointSize,
-		pos,
-		radiusAxis,
-		radiusAxisTicks,
-		stackedData,
-		stackedDomain: stackedData ? (layout === "centric" ? radiusAxis : angleAxis).scale.domain() : null,
-		startAngle
-	});
-});
-var selectRadialBarLegendPayload = createSelector([selectChartDataAndAlwaysIgnoreIndexes, (_s, l) => l], ({ chartData, dataStartIndex, dataEndIndex }, legendType) => {
-	if (chartData == null) return [];
-	const displayedData = chartData.slice(dataStartIndex, dataEndIndex + 1);
-	if (displayedData.length === 0) return [];
-	return displayedData.map((entry) => {
-		return {
-			type: legendType,
-			value: entry.name,
-			color: entry.fill,
-			payload: entry
-		};
-	});
-});
-//#endregion
-export { selectRadialBarLegendPayload, selectRadialBarSectors };

package/dist/es/state/selectors/rootPropsSelectors.mjs

@@ -1,14 +0,0 @@
-//#region src/state/selectors/rootPropsSelectors.ts
-var selectRootMaxBarSize = (state) => state.rootProps.maxBarSize;
-var selectBarGap = (state) => state.rootProps.barGap;
-function selectBarCategoryGap(state) {
-	return state.rootProps.barCategoryGap;
-}
-var selectRootBarSize = (state) => state.rootProps.barSize;
-var selectStackOffsetType = (state) => state.rootProps.stackOffset;
-var selectChartName = (state) => state.options.chartName;
-var selectSyncId = (state) => state.rootProps.syncId;
-var selectSyncMethod = (state) => state.rootProps.syncMethod;
-var selectEventEmitter = (state) => state.options.eventEmitter;
-//#endregion
-export { selectBarCategoryGap, selectBarGap, selectChartName, selectEventEmitter, selectRootBarSize, selectRootMaxBarSize, selectStackOffsetType, selectSyncId, selectSyncMethod };

package/dist/es/state/selectors/scatterSelectors.mjs

@@ -1,134 +0,0 @@
-import { isNullish } from "../../utils/validate.mjs";
-import { selectChartDataWithIndexesIfNotInPanorama } from "./dataSelectors.mjs";
-import { getCateCoordinateOfLine, getValueByDataKey } from "../../utils/chart.mjs";
-import { implicitZAxis, selectAxisWithScale, selectTicksOfGraphicalItem, selectUnfilteredCartesianItems, selectZAxisWithScale } from "./axisSelectors.mjs";
-import { toRaw } from "vue";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/scatterSelectors.ts
-function selectXAxisWithScale(state, xAxisId, _yAxisId, _zAxisId, _scatterSettings, isPanorama) {
-	return selectAxisWithScale(state, "xAxis", xAxisId, isPanorama);
-}
-function selectXAxisTicks(state, xAxisId, _yAxisId, _zAxisId, _scatterSettings, isPanorama) {
-	return selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama);
-}
-function selectYAxisWithScale(state, _xAxisId, yAxisId, _zAxisId, _scatterSettings, isPanorama) {
-	return selectAxisWithScale(state, "yAxis", yAxisId, isPanorama);
-}
-function selectYAxisTicks(state, _xAxisId, yAxisId, _zAxisId, _scatterSettings, isPanorama) {
-	return selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama);
-}
-function selectZAxis(state, _xAxisId, _yAxisId, zAxisId) {
-	return selectZAxisWithScale(state, "zAxis", zAxisId, false);
-}
-function pickScatterSettings(_state, _xAxisId, _yAxisId, _zAxisId, scatterSettings) {
-	return scatterSettings;
-}
-function scatterChartDataSelector(state, xAxisId, yAxisId, _zAxisId, _scatterSettings, isPanorama) {
-	return selectChartDataWithIndexesIfNotInPanorama(state, xAxisId, yAxisId, isPanorama);
-}
-var selectSynchronisedScatterSettings = createSelector([selectUnfilteredCartesianItems, pickScatterSettings], (graphicalItems, scatterSettingsFromProps) => {
-	if (graphicalItems.some((cgis) => cgis.type === "scatter" && scatterSettingsFromProps.dataKey === cgis.dataKey && scatterSettingsFromProps.data === cgis.data)) return scatterSettingsFromProps;
-});
-function computeScatterPoints({ displayedData, xAxis, yAxis, zAxis, scatterSettings, xAxisTicks, yAxisTicks }) {
-	const xAxisDataKey = isNullish(xAxis.dataKey) ? scatterSettings.dataKey : xAxis.dataKey;
-	const yAxisDataKey = isNullish(yAxis.dataKey) ? scatterSettings.dataKey : yAxis.dataKey;
-	const zAxisDataKey = zAxis && zAxis.dataKey;
-	const defaultRangeZ = zAxis ? zAxis.range : implicitZAxis.range;
-	const defaultZ = defaultRangeZ && defaultRangeZ[0];
-	const xBandSize = xAxis.scale.bandwidth ? xAxis.scale.bandwidth() : 0;
-	const yBandSize = yAxis.scale.bandwidth ? yAxis.scale.bandwidth() : 0;
-	return displayedData.map((rawEntry, index) => {
-		const entry = toRaw(rawEntry);
-		const x = getValueByDataKey(entry, xAxisDataKey);
-		const y = getValueByDataKey(entry, yAxisDataKey);
-		const z = !isNullish(zAxisDataKey) && getValueByDataKey(entry, zAxisDataKey) || "-";
-		const tooltipPayload = [{
-			name: isNullish(xAxis.dataKey) ? scatterSettings.name : xAxis.name || String(xAxis.dataKey),
-			unit: xAxis.unit || "",
-			value: x,
-			payload: entry,
-			dataKey: xAxisDataKey,
-			type: scatterSettings.tooltipType
-		}, {
-			name: isNullish(yAxis.dataKey) ? scatterSettings.name : yAxis.name || String(yAxis.dataKey),
-			unit: yAxis.unit || "",
-			value: y,
-			payload: entry,
-			dataKey: yAxisDataKey,
-			type: scatterSettings.tooltipType
-		}];
-		if (z !== "-" && zAxis != null) tooltipPayload.push({
-			name: zAxis.name || String(zAxis.dataKey),
-			unit: zAxis.unit || "",
-			value: z,
-			payload: entry,
-			dataKey: zAxisDataKey,
-			type: scatterSettings.tooltipType
-		});
-		const cx = getCateCoordinateOfLine({
-			axis: xAxis,
-			ticks: xAxisTicks,
-			bandSize: xBandSize,
-			entry,
-			index,
-			dataKey: xAxisDataKey
-		});
-		const cy = getCateCoordinateOfLine({
-			axis: yAxis,
-			ticks: yAxisTicks,
-			bandSize: yBandSize,
-			entry,
-			index,
-			dataKey: yAxisDataKey
-		});
-		const size = z !== "-" && zAxis != null ? zAxis.scale(z) : defaultZ;
-		const radius = size == null ? 0 : Math.sqrt(Math.max(size, 0) / Math.PI);
-		return {
-			...entry,
-			cx: cx ?? void 0,
-			cy: cy ?? void 0,
-			x: cx == null ? void 0 : cx - radius,
-			y: cy == null ? void 0 : cy - radius,
-			width: 2 * radius,
-			height: 2 * radius,
-			size,
-			node: {
-				x,
-				y,
-				z
-			},
-			tooltipPayload,
-			tooltipPosition: {
-				x: cx,
-				y: cy
-			},
-			payload: entry
-		};
-	});
-}
-var selectScatterPoints = createSelector([
-	scatterChartDataSelector,
-	selectXAxisWithScale,
-	selectXAxisTicks,
-	selectYAxisWithScale,
-	selectYAxisTicks,
-	selectZAxis,
-	selectSynchronisedScatterSettings
-], ({ chartData, dataStartIndex, dataEndIndex }, xAxis, xAxisTicks, yAxis, yAxisTicks, zAxis, scatterSettings) => {
-	if (scatterSettings == null) return;
-	let displayedData;
-	if (scatterSettings?.data?.length > 0) displayedData = scatterSettings.data;
-	else displayedData = chartData?.slice(dataStartIndex, dataEndIndex + 1);
-	if (displayedData == null || xAxis == null || yAxis == null || xAxisTicks?.length === 0 || yAxisTicks?.length === 0) return;
-	return computeScatterPoints({
-		displayedData,
-		xAxis,
-		yAxis,
-		zAxis,
-		scatterSettings,
-		xAxisTicks,
-		yAxisTicks
-	});
-});
-//#endregion
-export { selectScatterPoints };

package/dist/es/state/selectors/selectActivePropsFromChartPointer.mjs

@@ -1,20 +0,0 @@
-import { selectChartOffset } from "./selectChartOffset.mjs";
-import { selectChartLayout } from "./common.mjs";
-import { selectPolarViewBox } from "./polarAxisSelectors.mjs";
-import { selectTooltipAxisRangeWithReverse, selectTooltipAxisTicks, selectTooltipAxisType } from "./tooltipSelectors.mjs";
-import { combineActiveProps, selectOrderedTooltipTicks } from "./selectors.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/selectActivePropsFromChartPointer.ts
-var pickChartPointer = (_state, chartPointer) => chartPointer;
-var selectActivePropsFromChartPointer = createSelector([
-	pickChartPointer,
-	selectChartLayout,
-	selectPolarViewBox,
-	selectTooltipAxisType,
-	selectTooltipAxisRangeWithReverse,
-	selectTooltipAxisTicks,
-	selectOrderedTooltipTicks,
-	selectChartOffset
-], combineActiveProps);
-//#endregion
-export { selectActivePropsFromChartPointer };

package/dist/es/state/selectors/selectAllAxes.mjs

@@ -1,10 +0,0 @@
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/selectAllAxes.ts
-var selectAllXAxes = createSelector((state) => state.cartesianAxis.xAxis, (xAxisMap) => {
-	return Object.values(xAxisMap);
-});
-var selectAllYAxes = createSelector((state) => state.cartesianAxis.yAxis, (yAxisMap) => {
-	return Object.values(yAxisMap);
-});
-//#endregion
-export { selectAllXAxes, selectAllYAxes };

package/dist/es/state/selectors/selectChartOffset.mjs

@@ -1,72 +0,0 @@
-import { selectChartHeight, selectChartWidth, selectMargin } from "./containerSelectors.mjs";
-import { selectAllXAxes, selectAllYAxes } from "./selectAllAxes.mjs";
-import { selectLegendSettings, selectLegendSize } from "./legendSelectors.mjs";
-import { appendOffsetOfLegend } from "../../utils/legend.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-import { get } from "lodash-es";
-//#region src/state/selectors/selectChartOffset.ts
-var selectBrushHeight = (state) => state.brush.height;
-var selectChartOffset = createSelector([
-	selectChartWidth,
-	selectChartHeight,
-	selectMargin,
-	selectBrushHeight,
-	selectAllXAxes,
-	selectAllYAxes,
-	selectLegendSettings,
-	selectLegendSize
-], (chartWidth, chartHeight, margin, brushHeight, xAxes, yAxes, legendSettings, legendSize) => {
-	const offsetH = yAxes.reduce((result, entry) => {
-		const { orientation } = entry;
-		if (!entry.mirror && !entry.hide) {
-			const width = typeof entry.width === "number" ? entry.width : 60;
-			return {
-				...result,
-				[orientation]: result[orientation] + width
-			};
-		}
-		return result;
-	}, {
-		left: margin.left || 0,
-		right: margin.right || 0
-	});
-	let offset = {
-		...xAxes.reduce((result, entry) => {
-			const { orientation } = entry;
-			if (!entry.mirror && !entry.hide) return {
-				...result,
-				[orientation]: get(result, `${orientation}`) + entry.height
-			};
-			return result;
-		}, {
-			top: margin.top || 0,
-			bottom: margin.bottom || 0
-		}),
-		...offsetH
-	};
-	const brushBottom = offset.bottom;
-	offset.bottom += brushHeight;
-	offset = appendOffsetOfLegend(offset, legendSettings, legendSize);
-	const offsetWidth = chartWidth - offset.left - offset.right;
-	const offsetHeight = chartHeight - offset.top - offset.bottom;
-	return {
-		brushBottom,
-		...offset,
-		width: Math.max(offsetWidth, 0),
-		height: Math.max(offsetHeight, 0)
-	};
-});
-var selectChartViewBox = createSelector(selectChartOffset, (offset) => ({
-	x: offset.left,
-	y: offset.top,
-	width: offset.width,
-	height: offset.height
-}));
-var selectAxisViewBox = createSelector(selectChartWidth, selectChartHeight, (width, height) => ({
-	x: 0,
-	y: 0,
-	width,
-	height
-}));
-//#endregion
-export { selectAxisViewBox, selectBrushHeight, selectChartOffset, selectChartViewBox };

package/dist/es/state/selectors/selectChartOffsetInternal.mjs

@@ -1,66 +0,0 @@
-import { selectChartHeight, selectChartWidth, selectMargin } from "./containerSelectors.mjs";
-import { selectAllXAxes, selectAllYAxes } from "./selectAllAxes.mjs";
-import { selectLegendSettings, selectLegendSize } from "./legendSelectors.mjs";
-import { appendOffsetOfLegend } from "../../utils/legend.mjs";
-import { selectBrushHeight } from "./selectChartOffset.mjs";
-import { get } from "es-toolkit/compat";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/selectChartOffsetInternal.ts
-/**
-* For internal use only.
-*
-* @param root state
-* @return ChartOffsetInternal
-*/
-var selectChartOffsetInternal = createSelector([
-	selectChartWidth,
-	selectChartHeight,
-	selectMargin,
-	selectBrushHeight,
-	selectAllXAxes,
-	selectAllYAxes,
-	selectLegendSettings,
-	selectLegendSize
-], (chartWidth, chartHeight, margin, brushHeight, xAxes, yAxes, legendSettings, legendSize) => {
-	const offsetH = yAxes.reduce((result, entry) => {
-		const { orientation } = entry;
-		if (!entry.mirror && !entry.hide) {
-			const width = typeof entry.width === "number" ? entry.width : 60;
-			return {
-				...result,
-				[orientation]: result[orientation] + width
-			};
-		}
-		return result;
-	}, {
-		left: margin.left || 0,
-		right: margin.right || 0
-	});
-	let offset = {
-		...xAxes.reduce((result, entry) => {
-			const { orientation } = entry;
-			if (!entry.mirror && !entry.hide) return {
-				...result,
-				[orientation]: get(result, `${orientation}`) + entry.height
-			};
-			return result;
-		}, {
-			top: margin.top || 0,
-			bottom: margin.bottom || 0
-		}),
-		...offsetH
-	};
-	const brushBottom = offset.bottom;
-	offset.bottom += brushHeight;
-	offset = appendOffsetOfLegend(offset, legendSettings, legendSize);
-	const offsetWidth = chartWidth - offset.left - offset.right;
-	const offsetHeight = chartHeight - offset.top - offset.bottom;
-	return {
-		brushBottom,
-		...offset,
-		width: Math.max(offsetWidth, 0),
-		height: Math.max(offsetHeight, 0)
-	};
-});
-//#endregion
-export { selectChartOffsetInternal };

package/dist/es/state/selectors/selectLegendArea.mjs

@@ -1,19 +0,0 @@
-import { selectChartHeight, selectChartWidth, selectMargin } from "./containerSelectors.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/selectLegendArea.ts
-/**
-* The margin-inset chart area. Outside-positioned legends are placed here,
-* beyond any axes.
-*/
-var selectLegendArea = createSelector([
-	selectChartWidth,
-	selectChartHeight,
-	selectMargin
-], (chartWidth, chartHeight, margin) => ({
-	x: margin?.left || 0,
-	y: margin?.top || 0,
-	width: Math.max(chartWidth - (margin?.left || 0) - (margin?.right || 0), 0),
-	height: Math.max(chartHeight - (margin?.top || 0) - (margin?.bottom || 0), 0)
-}));
-//#endregion
-export { selectLegendArea };

package/dist/es/state/selectors/selectTooltipEventType.mjs

@@ -1,22 +0,0 @@
-import { useAppSelector } from "../hooks.mjs";
-//#region src/state/selectors/selectTooltipEventType.ts
-function selectDefaultTooltipEventType(state) {
-	return state.options.defaultTooltipEventType;
-}
-function selectValidateTooltipEventTypes(state) {
-	return state.options.validateTooltipEventTypes;
-}
-function combineTooltipEventType(shared, defaultTooltipEventType, validateTooltipEventTypes) {
-	if (shared == null) return defaultTooltipEventType;
-	const eventType = shared ? "axis" : "item";
-	if (validateTooltipEventTypes == null) return defaultTooltipEventType;
-	return validateTooltipEventTypes.includes(eventType) ? eventType : defaultTooltipEventType;
-}
-function selectTooltipEventType(state, shared) {
-	return combineTooltipEventType(shared, selectDefaultTooltipEventType(state), selectValidateTooltipEventTypes(state));
-}
-function useTooltipEventType(shared) {
-	return useAppSelector((state) => selectTooltipEventType(state, shared));
-}
-//#endregion
-export { combineTooltipEventType, selectDefaultTooltipEventType, selectTooltipEventType, selectValidateTooltipEventTypes, useTooltipEventType };

package/dist/es/state/selectors/selectTooltipPayloadSearcher.mjs

@@ -1,6 +0,0 @@
-//#region src/state/selectors/selectTooltipPayloadSearcher.ts
-function selectTooltipPayloadSearcher(state) {
-	return state.options.tooltipPayloadSearcher;
-}
-//#endregion
-export { selectTooltipPayloadSearcher };

package/dist/es/state/selectors/selectTooltipSettings.mjs

@@ -1,4 +0,0 @@
-//#region src/state/selectors/selectTooltipSettings.ts
-var selectTooltipSettings = (state) => state.tooltip.settings;
-//#endregion
-export { selectTooltipSettings };

package/dist/es/state/selectors/selectTooltipState.mjs

@@ -1,4 +0,0 @@
-//#region src/state/selectors/selectTooltipState.ts
-var selectTooltipState = (state) => state.tooltip;
-//#endregion
-export { selectTooltipState };