vccs 0.0.1 → 0.2.0

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

@@ -0,0 +1,241 @@
+import { isNullish } from "../../utils/validate.mjs";
+import { selectChartDataWithIndexesIfNotInPanorama } from "./dataSelectors.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { selectBarCategoryGap, selectBarGap, selectRootBarSize, selectRootMaxBarSize } from "./rootPropsSelectors.mjs";
+import { getPercentValue } from "../../utils/data.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { getBandSizeOfAxis } from "../../utils/chart.mjs";
+import { selectAxisWithScale, selectCartesianAxisSize, selectStackGroups, selectTicksOfGraphicalItem, selectUnfilteredCartesianItems } from "./axisSelectors.mjs";
+import { computeBarRectangles } from "../../cartesian/bar/utils.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/barSelectors.ts
+var pickXAxisId = (_state, xAxisId) => xAxisId;
+var pickYAxisId = (_state, _xAxisId, yAxisId) => yAxisId;
+function pickIsPanorama(_state, _xAxisId, _yAxisId, isPanorama) {
+	return isPanorama;
+}
+function pickBarSettings(_state, _xAxisId, _yAxisId, _isPanorama, barSettings) {
+	return barSettings;
+}
+function pickMaxBarSize(_state, _xAxisId, _yAxisId, _isPanorama, barSettings) {
+	return barSettings.maxBarSize;
+}
+function getBarSize(globalSize, totalSize, selfSize) {
+	const barSize = selfSize ?? globalSize;
+	return isNullish(barSize) ? void 0 : getPercentValue(barSize, totalSize, 0);
+}
+var selectAllVisibleBars = createSelector([
+	selectChartLayout,
+	selectUnfilteredCartesianItems,
+	pickXAxisId,
+	pickYAxisId,
+	pickIsPanorama
+], (layout, allItems, xAxisId, yAxisId, isPanorama) => allItems.filter((i) => {
+	if (layout === "horizontal") return i.xAxisId === xAxisId;
+	return i.yAxisId === yAxisId;
+}).filter((i) => i.isPanorama === isPanorama).filter((i) => i.hide === false).filter((i) => i.type === "bar"));
+function selectBarStackGroups(state, xAxisId, yAxisId, isPanorama) {
+	if (selectChartLayout(state) === "horizontal") return selectStackGroups(state, "yAxis", yAxisId, isPanorama);
+	return selectStackGroups(state, "xAxis", xAxisId, isPanorama);
+}
+function selectBarCartesianAxisSize(state, xAxisId, yAxisId) {
+	if (selectChartLayout(state) === "horizontal") return selectCartesianAxisSize(state, "xAxis", xAxisId);
+	return selectCartesianAxisSize(state, "yAxis", yAxisId);
+}
+function combineBarSizeList(allBars, globalSize, totalSize) {
+	const initialValue = {};
+	const stackedBars = allBars.filter((b) => b.stackId != null);
+	const unstackedBars = allBars.filter((b) => b.stackId == null);
+	const groupByStack = stackedBars.reduce((acc, bar) => {
+		if (!acc[bar.stackId]) acc[bar.stackId] = [];
+		acc[bar.stackId].push(bar);
+		return acc;
+	}, initialValue);
+	const stackedSizeList = Object.entries(groupByStack).map(([stackId, bars]) => {
+		return {
+			stackId,
+			dataKeys: bars.map((b) => b.dataKey),
+			barSize: getBarSize(globalSize, totalSize, bars[0].barSize)
+		};
+	});
+	const unstackedSizeList = unstackedBars.map((b) => {
+		return {
+			stackId: void 0,
+			dataKeys: [b.dataKey],
+			barSize: getBarSize(globalSize, totalSize, b.barSize)
+		};
+	});
+	return [...stackedSizeList, ...unstackedSizeList];
+}
+var selectBarSizeList = createSelector([
+	selectAllVisibleBars,
+	selectRootBarSize,
+	selectBarCartesianAxisSize
+], combineBarSizeList);
+function selectBarBandSize(state, xAxisId, yAxisId, isPanorama, barSettings) {
+	const layout = selectChartLayout(state);
+	const globalMaxBarSize = selectRootMaxBarSize(state);
+	const { maxBarSize: childMaxBarSize } = barSettings;
+	const maxBarSize = isNullish(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize;
+	let axis, ticks;
+	if (layout === "horizontal") {
+		axis = selectAxisWithScale(state, "xAxis", xAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama);
+	} else {
+		axis = selectAxisWithScale(state, "yAxis", yAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama);
+	}
+	return getBandSizeOfAxis(axis, ticks, true) ?? maxBarSize ?? 0;
+}
+function selectAxisBandSize(state, xAxisId, yAxisId, isPanorama) {
+	const layout = selectChartLayout(state);
+	let axis, ticks;
+	if (layout === "horizontal") {
+		axis = selectAxisWithScale(state, "xAxis", xAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama);
+	} else {
+		axis = selectAxisWithScale(state, "yAxis", yAxisId, isPanorama);
+		ticks = selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama);
+	}
+	return getBandSizeOfAxis(axis, ticks);
+}
+function getBarPositions(barGap, barCategoryGap, bandSize, sizeList, maxBarSize) {
+	const len = sizeList.length;
+	if (len < 1) return null;
+	let realBarGap = getPercentValue(barGap, bandSize, 0, true);
+	let result;
+	const initialValue = [];
+	if (sizeList[0].barSize === +sizeList[0].barSize) {
+		let useFull = false;
+		let fullBarSize = bandSize / len;
+		let sum = sizeList.reduce((res, entry) => res + entry.barSize || 0, 0);
+		sum += (len - 1) * realBarGap;
+		if (sum >= bandSize) {
+			sum -= (len - 1) * realBarGap;
+			realBarGap = 0;
+		}
+		if (sum >= bandSize && fullBarSize > 0) {
+			useFull = true;
+			fullBarSize *= .9;
+			sum = len * fullBarSize;
+		}
+		let prev = {
+			offset: ((bandSize - sum) / 2 >> 0) - realBarGap,
+			size: 0
+		};
+		result = sizeList.reduce((res, entry) => {
+			const newPosition = {
+				stackId: entry.stackId,
+				dataKeys: entry.dataKeys,
+				position: {
+					offset: prev.offset + prev.size + realBarGap,
+					size: useFull ? fullBarSize : entry.barSize
+				}
+			};
+			const newRes = [...res, newPosition];
+			prev = newRes[newRes.length - 1].position;
+			return newRes;
+		}, initialValue);
+	} else {
+		const offset = getPercentValue(barCategoryGap, bandSize, 0, true);
+		if (bandSize - 2 * offset - (len - 1) * realBarGap <= 0) realBarGap = 0;
+		let originalSize = (bandSize - 2 * offset - (len - 1) * realBarGap) / len;
+		if (originalSize > 1) originalSize >>= 0;
+		const size = maxBarSize === +maxBarSize ? Math.min(originalSize, maxBarSize) : originalSize;
+		result = sizeList.reduce((res, entry, i) => [...res, {
+			stackId: entry.stackId,
+			dataKeys: entry.dataKeys,
+			position: {
+				offset: offset + (originalSize + realBarGap) * i + (originalSize - size) / 2,
+				size
+			}
+		}], initialValue);
+	}
+	return result;
+}
+function combineAllBarPositions(sizeList, globalMaxBarSize, barGap, barCategoryGap, barBandSize, bandSize, childMaxBarSize) {
+	const maxBarSize = isNullish(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize;
+	let allBarPositions = getBarPositions(barGap, barCategoryGap, barBandSize !== bandSize ? barBandSize : bandSize, sizeList, maxBarSize);
+	if (barBandSize !== bandSize && allBarPositions != null) allBarPositions = allBarPositions.map((pos) => ({
+		...pos,
+		position: {
+			...pos.position,
+			offset: pos.position.offset - barBandSize / 2
+		}
+	}));
+	return allBarPositions;
+}
+var selectAllBarPositions = createSelector([
+	selectBarSizeList,
+	selectRootMaxBarSize,
+	selectBarGap,
+	selectBarCategoryGap,
+	selectBarBandSize,
+	selectAxisBandSize,
+	pickMaxBarSize
+], combineAllBarPositions);
+function selectXAxisWithScale(state, xAxisId, _yAxisId, isPanorama) {
+	return selectAxisWithScale(state, "xAxis", xAxisId, isPanorama);
+}
+function selectYAxisWithScale(state, _xAxisId, yAxisId, isPanorama) {
+	return selectAxisWithScale(state, "yAxis", yAxisId, isPanorama);
+}
+function selectXAxisTicks(state, xAxisId, _yAxisId, isPanorama) {
+	return selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama);
+}
+function selectYAxisTicks(state, _xAxisId, yAxisId, isPanorama) {
+	return selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama);
+}
+var selectBarPosition = createSelector([selectAllBarPositions, pickBarSettings], (allBarPositions, barSettings) => {
+	if (allBarPositions == null) return;
+	const position = allBarPositions.find((p) => p.stackId === barSettings.stackId && p.dataKeys.includes(barSettings.dataKey));
+	if (position == null) return;
+	return position.position;
+});
+function combineStackedData(stackGroups, barSettings) {
+	if (!stackGroups || barSettings?.dataKey == null) return;
+	const { stackId } = barSettings;
+	const stackGroup = stackGroups[stackId];
+	if (!stackGroup) return;
+	const { stackedData } = stackGroup;
+	if (!stackedData) return;
+	return stackedData.find((sd) => sd.key === barSettings.dataKey);
+}
+var selectSynchronisedBarSettings = createSelector([selectUnfilteredCartesianItems, pickBarSettings], (graphicalItems, barSettingsFromProps) => {
+	if (graphicalItems.some((cgis) => cgis.type === "bar" && barSettingsFromProps.dataKey === cgis.dataKey && barSettingsFromProps.stackId === cgis.stackId && barSettingsFromProps.stackId === cgis.stackId)) return barSettingsFromProps;
+});
+var selectBarRectangles = createSelector([
+	selectChartOffset,
+	selectXAxisWithScale,
+	selectYAxisWithScale,
+	selectXAxisTicks,
+	selectYAxisTicks,
+	selectBarPosition,
+	selectChartLayout,
+	selectChartDataWithIndexesIfNotInPanorama,
+	selectAxisBandSize,
+	createSelector([selectBarStackGroups, pickBarSettings], combineStackedData),
+	selectSynchronisedBarSettings
+], (offset, xAxis, yAxis, xAxisTicks, yAxisTicks, pos, layout, { chartData, dataStartIndex, dataEndIndex }, bandSize, stackedData, barSettings) => {
+	if (barSettings == null || pos == null || layout !== "horizontal" && layout !== "vertical" || xAxis == null || yAxis == null || xAxisTicks == null || yAxisTicks == null) return;
+	const { data } = barSettings;
+	let displayedData;
+	if ((data?.length ?? 0) > 0) displayedData = data;
+	else displayedData = chartData?.slice(dataStartIndex, dataEndIndex + 1);
+	if (displayedData == null) return;
+	return computeBarRectangles({
+		layout,
+		barSettings,
+		pos,
+		bandSize,
+		xAxis,
+		yAxis,
+		xAxisTicks,
+		yAxisTicks,
+		stackedData,
+		displayedData,
+		offset
+	});
+});
+//#endregion
+export { combineAllBarPositions, combineBarSizeList, combineStackedData, selectBarRectangles };

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

@@ -0,0 +1,18 @@
+import { isNumber } from "../../utils/validate.mjs";
+import { selectMargin } from "./containerSelectors.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/brushSelectors.ts
+var selectBrushSettings = (state) => state.brush;
+var selectBrushDimensions = createSelector([
+	selectBrushSettings,
+	selectChartOffset,
+	selectMargin
+], (brushSettings, offset, margin) => ({
+	height: brushSettings.height,
+	x: isNumber(brushSettings.x) ? brushSettings.x : offset.left,
+	y: isNumber(brushSettings.y) ? brushSettings.y : offset.top + offset.height + offset.brushBottom - (margin?.bottom || 0),
+	width: isNumber(brushSettings.width) ? brushSettings.width : offset.width
+}));
+//#endregion
+export { selectBrushDimensions, selectBrushSettings };

package/dist/es/state/selectors/combiners/combineActiveLabel.mjs

@@ -0,0 +1,9 @@
+import { isNan } from "../../../utils/validate.mjs";
+//#region src/state/selectors/combiners/combineActiveLabel.ts
+function combineActiveLabel(tooltipTicks, activeIndex) {
+	const n = Number(activeIndex);
+	if (isNan(n) || activeIndex == null) return;
+	return n >= 0 ? tooltipTicks?.[n]?.value : void 0;
+}
+//#endregion
+export { combineActiveLabel };

package/dist/es/state/selectors/combiners/combineActiveTooltipIndex.mjs

@@ -0,0 +1,43 @@
+import { isWellBehavedNumber } from "../../../utils/validate.mjs";
+import { getValueByDataKey } from "../../../utils/chart.mjs";
+import { isWellFormedNumberDomain } from "../../../utils/isDomainSpecifiedByUser.mjs";
+//#region src/state/selectors/combiners/combineActiveTooltipIndex.ts
+function toFiniteNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (value instanceof Date) {
+		const numericValue = value.valueOf();
+		return Number.isFinite(numericValue) ? numericValue : void 0;
+	}
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function isValueWithinNumberDomain(value, domain) {
+	const numericValue = toFiniteNumber(value);
+	const lowerBound = domain[0];
+	const upperBound = domain[1];
+	if (numericValue === void 0) return false;
+	return numericValue >= Math.min(lowerBound, upperBound) && numericValue <= Math.max(lowerBound, upperBound);
+}
+function isValueWithinDomain(entry, axisDataKey, domain) {
+	if (domain == null || axisDataKey == null) return true;
+	const value = getValueByDataKey(entry, axisDataKey);
+	if (value == null) return true;
+	if (!isWellFormedNumberDomain(domain)) return true;
+	return isValueWithinNumberDomain(value, domain);
+}
+function combineActiveTooltipIndex(tooltipInteraction, chartData, axisDataKey, domain) {
+	const desiredIndex = tooltipInteraction?.index;
+	if (desiredIndex == null) return null;
+	const indexAsNumber = Number(desiredIndex);
+	if (!isWellBehavedNumber(indexAsNumber)) return desiredIndex;
+	const lowerLimit = 0;
+	let upperLimit = Infinity;
+	if (chartData.length > 0) upperLimit = chartData.length - 1;
+	const clampedIndex = Math.max(lowerLimit, Math.min(indexAsNumber, upperLimit));
+	const entry = chartData[clampedIndex];
+	if (entry == null) return String(clampedIndex);
+	if (!isValueWithinDomain(entry, axisDataKey, domain)) return null;
+	return String(clampedIndex);
+}
+//#endregion
+export { combineActiveTooltipIndex };

package/dist/es/state/selectors/combiners/combineAxisRangeWithReverse.mjs

@@ -0,0 +1,8 @@
+//#region src/state/selectors/combiners/combineAxisRangeWithReverse.ts
+function combineAxisRangeWithReverse(axisSettings, axisRange) {
+	if (!axisSettings || !axisRange) return;
+	if (axisSettings?.reversed) return [axisRange[1], axisRange[0]];
+	return axisRange;
+}
+//#endregion
+export { combineAxisRangeWithReverse };

package/dist/es/state/selectors/combiners/combineCoordinateForDefaultIndex.mjs

@@ -0,0 +1,21 @@
+//#region src/state/selectors/combiners/combineCoordinateForDefaultIndex.ts
+function combineCoordinateForDefaultIndex(width, height, layout, offset, tooltipTicks, defaultIndex, tooltipConfigurations, tooltipPayloadSearcher) {
+	if (defaultIndex == null || offset == null) return;
+	const firstConfiguration = tooltipConfigurations[0];
+	const maybePosition = firstConfiguration == null ? void 0 : tooltipPayloadSearcher?.(firstConfiguration.positions, defaultIndex);
+	if (maybePosition != null) return maybePosition;
+	const tick = tooltipTicks?.[Number(defaultIndex)];
+	if (!tick) return;
+	switch (layout) {
+		case "horizontal": return {
+			x: tick.coordinate,
+			y: (offset.top + height) / 2
+		};
+		default: return {
+			x: (offset.left + width) / 2,
+			y: tick.coordinate
+		};
+	}
+}
+//#endregion
+export { combineCoordinateForDefaultIndex };

package/dist/es/state/selectors/combiners/combineTooltipInteractionState.mjs

@@ -0,0 +1,37 @@
+import { noInteraction } from "../../tooltipSlice.mjs";
+//#region src/state/selectors/combiners/combineTooltipInteractionState.ts
+function chooseAppropriateMouseInteraction(tooltipState, tooltipEventType, trigger) {
+	if (tooltipEventType === "axis") {
+		if (trigger === "click") return tooltipState.axisInteraction.click;
+		return tooltipState.axisInteraction.hover;
+	}
+	if (trigger === "click") return tooltipState.itemInteraction.click;
+	return tooltipState.itemInteraction.hover;
+}
+function hasBeenActivePreviously(tooltipInteractionState) {
+	return tooltipInteractionState.index != null;
+}
+function combineTooltipInteractionState(tooltipState, tooltipEventType, trigger, defaultIndex) {
+	const appropriateMouseInteraction = chooseAppropriateMouseInteraction(tooltipState, tooltipEventType, trigger);
+	if (appropriateMouseInteraction?.active) return appropriateMouseInteraction;
+	if (tooltipState.keyboardInteraction.active) return tooltipState.keyboardInteraction;
+	if (tooltipState.syncInteraction.active && tooltipState.syncInteraction.index != null) return tooltipState.syncInteraction;
+	const activeFromProps = tooltipState.settings.active === true;
+	if (hasBeenActivePreviously(appropriateMouseInteraction)) {
+		if (activeFromProps) return {
+			...appropriateMouseInteraction,
+			active: true
+		};
+	} else if (defaultIndex != null) return {
+		active: true,
+		coordinate: void 0,
+		dataKey: void 0,
+		index: defaultIndex
+	};
+	return {
+		...noInteraction,
+		coordinate: appropriateMouseInteraction?.coordinate
+	};
+}
+//#endregion
+export { combineTooltipInteractionState };

package/dist/es/state/selectors/combiners/combineTooltipPayloadConfigurations.mjs

@@ -0,0 +1,13 @@
+//#region src/state/selectors/combiners/combineTooltipPayloadConfigurations.ts
+function combineTooltipPayloadConfigurations(tooltipState, tooltipEventType, trigger, defaultIndex) {
+	if (tooltipEventType === "axis") return tooltipState.tooltipItemPayloads;
+	if (tooltipState.tooltipItemPayloads.length === 0) return [];
+	let filterByDataKey;
+	if (trigger === "hover") filterByDataKey = tooltipState.itemInteraction.hover.dataKey;
+	else filterByDataKey = tooltipState.itemInteraction.click.dataKey;
+	if (tooltipState.syncInteraction.active && filterByDataKey == null) return tooltipState.tooltipItemPayloads;
+	if (filterByDataKey == null && defaultIndex != null) return [tooltipState.tooltipItemPayloads[0]];
+	return tooltipState.tooltipItemPayloads.filter((tpc) => tpc.settings?.dataKey === filterByDataKey);
+}
+//#endregion
+export { combineTooltipPayloadConfigurations };

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

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

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

@@ -0,0 +1,7 @@
+//#region src/state/selectors/containerSelectors.ts
+var selectChartWidth = (state) => state.layout.width;
+var selectChartHeight = (state) => state.layout.height;
+var selectContainerScale = (state) => state.layout.scale;
+var selectMargin = (state) => state.layout.margin;
+//#endregion
+export { selectChartHeight, selectChartWidth, selectContainerScale, selectMargin };

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

@@ -0,0 +1,35 @@
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/dataSelectors.ts
+/**
+* This selector always returns the data with the indexes set by a Brush.
+* Trouble is, that might or might not be what you want.
+*
+* In charts with Brush, you will sometimes want to select the full range of data, and sometimes the one decided by the Brush
+* - even if the Brush is active, the panorama inside the Brush should show the full range of data.
+*
+* So instead of this selector, consider using either selectChartDataAndAlwaysIgnoreIndexes or selectChartDataWithIndexesIfNotInPanorama
+*
+* @param state RechartsRootState
+* @returns data defined on the chart root element, such as BarChart or ScatterChart
+*/
+var selectChartDataWithIndexes = (state) => state.chartData;
+/**
+* This selector will always return the full range of data, ignoring the indexes set by a Brush.
+* Useful for when you want to render the full range of data, even if a Brush is active.
+* For example: in the Brush panorama, in Legend, in Tooltip.
+*/
+var selectChartDataAndAlwaysIgnoreIndexes = createSelector([selectChartDataWithIndexes], (dataState) => {
+	const dataEndIndex = dataState.chartData != null ? dataState.chartData.length - 1 : 0;
+	return {
+		chartData: dataState.chartData,
+		computedData: dataState.computedData,
+		dataEndIndex,
+		dataStartIndex: 0
+	};
+});
+function selectChartDataWithIndexesIfNotInPanorama(state, _xAxisId, _yAxisId, isPanorama) {
+	if (isPanorama) return selectChartDataAndAlwaysIgnoreIndexes(state);
+	return selectChartDataWithIndexes(state);
+}
+//#endregion
+export { selectChartDataAndAlwaysIgnoreIndexes, selectChartDataWithIndexes, selectChartDataWithIndexesIfNotInPanorama };

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

@@ -0,0 +1,38 @@
+import { selectChartDataAndAlwaysIgnoreIndexes } from "./dataSelectors.mjs";
+import { selectChartOffset } from "./selectChartOffset.mjs";
+import { computeFunnelTrapezoids } from "../../cartesian/funnel/utils.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/funnelSelectors.ts
+function pickFunnelSettings(_state, funnelSettings) {
+	return funnelSettings;
+}
+var selectFunnelTrapezoids = createSelector([
+	selectChartOffset,
+	pickFunnelSettings,
+	selectChartDataAndAlwaysIgnoreIndexes
+], (offset, { data, dataKey, nameKey, tooltipType, lastShapeType, reversed, customWidth, presentationProps }, { chartData }) => {
+	let displayedData;
+	if (data != null && data.length > 0) displayedData = data;
+	else if (chartData != null && chartData.length > 0) displayedData = chartData;
+	if (displayedData && displayedData.length) displayedData = displayedData.map((entry, index) => ({
+		payload: entry,
+		...presentationProps,
+		...entry
+	}));
+	else return {
+		trapezoids: [],
+		data: displayedData
+	};
+	return computeFunnelTrapezoids({
+		dataKey,
+		nameKey,
+		displayedData,
+		tooltipType,
+		lastShapeType,
+		reversed,
+		offset,
+		customWidth
+	});
+});
+//#endregion
+export { selectFunnelTrapezoids };

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

@@ -0,0 +1,10 @@
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/legendSelectors.ts
+var selectLegendSettings = (state) => state.legend.settings;
+var selectLegendSize = (state) => state.legend.size;
+function selectAllLegendPayload2DArray(state) {
+	return state.legend.payload;
+}
+var selectLegendPayload = createSelector([selectAllLegendPayload2DArray], (payloads) => payloads.flat(1));
+//#endregion
+export { selectLegendPayload, selectLegendSettings, selectLegendSize };

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

@@ -0,0 +1,64 @@
+import { isCategoricalAxis } from "../../utils/validate.mjs";
+import { selectChartDataWithIndexesIfNotInPanorama } from "./dataSelectors.mjs";
+import { selectChartLayout } from "./common.mjs";
+import { getBandSizeOfAxis } from "../../utils/chart.mjs";
+import { selectAxisWithScale, selectTicksOfGraphicalItem, selectUnfilteredCartesianItems } from "./axisSelectors.mjs";
+import { computeLinePoints } from "../../cartesian/line/utils.mjs";
+import { createSelector } from "@reduxjs/toolkit";
+//#region src/state/selectors/lineSelectors.ts
+function selectXAxisWithScale(state, xAxisId, _yAxisId, isPanorama) {
+	return selectAxisWithScale(state, "xAxis", xAxisId, isPanorama);
+}
+function selectXAxisTicks(state, xAxisId, _yAxisId, isPanorama) {
+	return selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama);
+}
+function selectYAxisWithScale(state, _xAxisId, yAxisId, isPanorama) {
+	return selectAxisWithScale(state, "yAxis", yAxisId, isPanorama);
+}
+function selectYAxisTicks(state, _xAxisId, yAxisId, isPanorama) {
+	return selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama);
+}
+var selectBandSize = createSelector([
+	selectChartLayout,
+	selectXAxisWithScale,
+	selectYAxisWithScale,
+	selectXAxisTicks,
+	selectYAxisTicks
+], (layout, xAxis, yAxis, xAxisTicks, yAxisTicks) => {
+	if (isCategoricalAxis(layout, "xAxis")) return getBandSizeOfAxis(xAxis, xAxisTicks, false);
+	return getBandSizeOfAxis(yAxis, yAxisTicks, false);
+});
+function pickLineSettings(_state, _xAxisId, _yAxisId, _isPanorama, lineSettings) {
+	return lineSettings;
+}
+var selectLinePoints = createSelector([
+	selectChartLayout,
+	selectXAxisWithScale,
+	selectYAxisWithScale,
+	selectXAxisTicks,
+	selectYAxisTicks,
+	createSelector([selectUnfilteredCartesianItems, pickLineSettings], (graphicalItems, lineSettingsFromProps) => {
+		if (graphicalItems.some((cgis) => cgis.type === "line" && lineSettingsFromProps.dataKey === cgis.dataKey && lineSettingsFromProps.data === cgis.data)) return lineSettingsFromProps;
+	}),
+	selectBandSize,
+	selectChartDataWithIndexesIfNotInPanorama
+], (layout, xAxis, yAxis, xAxisTicks, yAxisTicks, lineSettings, bandSize, { chartData, dataStartIndex, dataEndIndex }) => {
+	if (lineSettings == null || xAxis == null || yAxis == null || xAxisTicks == null || yAxisTicks == null || xAxisTicks.length === 0 || yAxisTicks.length === 0) return;
+	const { dataKey, data } = lineSettings;
+	let displayedData;
+	if (data?.length > 0) displayedData = data;
+	else displayedData = chartData?.slice(dataStartIndex, dataEndIndex + 1);
+	if (displayedData == null) return;
+	return computeLinePoints({
+		layout,
+		xAxis,
+		yAxis,
+		xAxisTicks,
+		yAxisTicks,
+		dataKey,
+		bandSize,
+		displayedData
+	});
+});
+//#endregion
+export { selectLinePoints };

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

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

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

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