vccs 0.0.1 → 0.2.0

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

@@ -0,0 +1,259 @@
+import { isCategoricalAxis, isNullish } from "../../utils/validate.mjs";
+import { selectChartDataAndAlwaysIgnoreIndexes, selectChartDataWithIndexes } from "./dataSelectors.mjs";
+import { selectBarCategoryGap, selectBarGap, selectRootBarSize, selectRootMaxBarSize, selectStackOffsetType } from "./rootPropsSelectors.mjs";
+import { mathSign } from "../../utils/data.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

@@ -0,0 +1,14 @@
+//#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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,69 @@
+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) return {
+			...result,
+			[orientation]: result[orientation] + entry.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

@@ -0,0 +1,66 @@
+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/selectTooltipEventType.mjs

@@ -0,0 +1,22 @@
+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

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

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

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

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

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