@solidports/recharts 0.1.0

package/src/state/selectors/combiners/combineActiveTooltipIndex.ts

@@ -0,0 +1,95 @@
+/* eslint-disable import/no-cycle */
+import { TooltipIndex, TooltipInteractionState } from "../../tooltipSlice"
+import { ChartData } from "../../chartDataSlice"
+import { isWellBehavedNumber } from "../../../util/isWellBehavedNumber"
+import { DataKey, CategoricalDomain, NumberDomain } from "../../../util/types"
+import { getValueByDataKey } from "../../../util/ChartUtils"
+import { isWellFormedNumberDomain } from "../../../util/isDomainSpecifiedByUser"
+
+function toFiniteNumber(value: unknown): number | undefined {
+	if (typeof value === "number") {
+		return Number.isFinite(value) ? value : undefined
+	}
+	if (value instanceof Date) {
+		const numericValue = value.valueOf()
+		return Number.isFinite(numericValue) ? numericValue : undefined
+	}
+	const parsed = Number(value)
+	return Number.isFinite(parsed) ? parsed : undefined
+}
+
+function isValueWithinNumberDomain(value: unknown, domain: NumberDomain): boolean {
+	const numericValue = toFiniteNumber(value)
+	const lowerBound = domain[0]
+	const upperBound = domain[1]
+
+	if (numericValue === undefined) {
+		return false
+	}
+
+	const min = Math.min(lowerBound, upperBound)
+	const max = Math.max(lowerBound, upperBound)
+	return numericValue >= min && numericValue <= max
+}
+
+function isValueWithinDomain(
+	entry: unknown,
+	axisDataKey: DataKey<unknown> | undefined,
+	domain: NumberDomain | CategoricalDomain | undefined,
+): boolean {
+	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)
+}
+
+export const combineActiveTooltipIndex = (
+	tooltipInteraction: TooltipInteractionState | undefined,
+	chartData: ChartData,
+	axisDataKey?: DataKey<unknown>,
+	domain?: NumberDomain | CategoricalDomain,
+): TooltipIndex | null => {
+	const desiredIndex: TooltipIndex | undefined = tooltipInteraction?.index
+	if (desiredIndex == null) {
+		return null
+	}
+
+	const indexAsNumber = Number(desiredIndex)
+	if (!isWellBehavedNumber(indexAsNumber)) {
+		return desiredIndex
+	}
+
+	/*
+	 * Zero is a trivial limit for single-dimensional charts like Line and Area,
+	 * but this also needs a support for multidimensional charts like Sankey and Treemap! TODO
+	 */
+	const lowerLimit = 0
+	let upperLimit: number = +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)
+}

package/src/state/selectors/combiners/combineAllBarPositions.ts

@@ -0,0 +1,122 @@
+/* eslint-disable import/no-cycle */
+import { getPercentValue, isNullish } from "../../../util/DataUtils"
+import { BarWithPosition, SizeList } from "../barSelectors"
+import { isWellBehavedNumber } from "../../../util/isWellBehavedNumber"
+import { BarPositionPosition } from "../../../util/ChartUtils"
+import { BarCategory } from "./combineBarSizeList"
+
+function getBarPositions(
+	barGap: string | number,
+	barCategoryGap: string | number,
+	bandSize: number,
+	sizeList: SizeList,
+	maxBarSize: number | undefined,
+): ReadonlyArray<BarWithPosition> | undefined {
+	const len = sizeList.length
+	if (len < 1) {
+		return undefined
+	}
+
+	let realBarGap = getPercentValue(barGap, bandSize, 0, true)
+
+	let result: ReadonlyArray<BarWithPosition>
+	const initialValue: ReadonlyArray<BarWithPosition> = []
+
+	// whether is barSize set by user
+	// Okay but why does it check only for the first element? What if the first element is set but others are not?
+	if (isWellBehavedNumber(sizeList[0]?.barSize)) {
+		let useFull = false
+		let fullBarSize: number = 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 *= 0.9
+			sum = len * fullBarSize
+		}
+
+		const offset = Math.round((bandSize - sum) / 2)
+		let prev: BarPositionPosition = { offset: offset - realBarGap, size: 0 }
+
+		result = sizeList.reduce(
+			(res: ReadonlyArray<BarWithPosition>, entry: BarCategory): ReadonlyArray<BarWithPosition> => {
+				const newPosition: BarWithPosition = {
+					stackId: entry.stackId,
+					dataKeys: entry.dataKeys,
+					position: {
+						offset: prev.offset + prev.size + realBarGap,
+						size: useFull ? fullBarSize : (entry.barSize ?? 0),
+					},
+				}
+				const newRes: Array<BarWithPosition> = [...res, newPosition]
+
+				prev = newPosition.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 = Math.round(originalSize)
+		}
+		const size = isWellBehavedNumber(maxBarSize) ? Math.min(originalSize, maxBarSize) : originalSize
+		result = sizeList.reduce(
+			(res: ReadonlyArray<BarWithPosition>, entry: BarCategory, i): ReadonlyArray<BarWithPosition> => [
+				...res,
+				{
+					stackId: entry.stackId,
+					dataKeys: entry.dataKeys,
+					position: {
+						offset: offset + (len * (originalSize - size)) / 2 + (size + realBarGap) * i,
+						size,
+					},
+				},
+			],
+			initialValue,
+		)
+	}
+
+	return result
+}
+
+export const combineAllBarPositions = (
+	sizeList: SizeList,
+	globalMaxBarSize: number | undefined,
+	barGap: string | number,
+	barCategoryGap: string | number,
+	barBandSize: number,
+	bandSize: number | undefined,
+	childMaxBarSize: number | undefined,
+): ReadonlyArray<BarWithPosition> | undefined => {
+	const maxBarSize: number | undefined = isNullish(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize
+
+	let allBarPositions: ReadonlyArray<BarWithPosition> | undefined = 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
+}

package/src/state/selectors/combiners/combineAxisRangeWithReverse.ts

@@ -0,0 +1,16 @@
+/* eslint-disable import/no-cycle */
+import { BaseCartesianAxis } from "../../cartesianAxisSlice"
+import { AxisRange } from "../axisSelectors"
+
+export const combineAxisRangeWithReverse = (
+	axisSettings: BaseCartesianAxis | undefined,
+	axisRange: AxisRange | undefined,
+): AxisRange | undefined => {
+	if (!axisSettings || !axisRange) {
+		return undefined
+	}
+	if (axisSettings?.reversed) {
+		return [axisRange[1], axisRange[0]]
+	}
+	return axisRange
+}

package/src/state/selectors/combiners/combineBarPosition.ts

@@ -0,0 +1,23 @@
+/* eslint-disable import/no-cycle */
+import { MaybeStackedGraphicalItem } from "../../types/StackedGraphicalItem"
+import { BarPositionPosition } from "../../../util/ChartUtils"
+import { BarWithPosition } from "../barSelectors"
+
+export const combineBarPosition = (
+	allBarPositions: ReadonlyArray<BarWithPosition> | undefined,
+	barSettings: MaybeStackedGraphicalItem | undefined,
+): BarPositionPosition | undefined => {
+	if (allBarPositions == null || barSettings == null) {
+		return undefined
+	}
+	const position = allBarPositions.find(
+		(p: BarWithPosition) =>
+			p.stackId === barSettings.stackId &&
+			barSettings.dataKey != null &&
+			p.dataKeys.includes(barSettings.dataKey),
+	)
+	if (position == null) {
+		return undefined
+	}
+	return position.position
+}

package/src/state/selectors/combiners/combineBarSizeList.ts

@@ -0,0 +1,80 @@
+/* eslint-disable import/no-cycle */
+import {
+	DefinitelyStackedGraphicalItem,
+	isStacked,
+	MaybeStackedGraphicalItem,
+} from "../../types/StackedGraphicalItem"
+import { StackId } from "../../../util/ChartUtils"
+import { SizeList } from "../barSelectors"
+import { getPercentValue, isNullish } from "../../../util/DataUtils"
+import { DataKey } from "../../../util/types"
+
+const getBarSize = (
+	globalSize: string | number | undefined,
+	totalSize: number | undefined,
+	selfSize: number | string | undefined,
+): number | undefined => {
+	const barSize: string | number | undefined = selfSize ?? globalSize
+
+	if (isNullish(barSize)) {
+		return undefined
+	}
+	return getPercentValue(barSize, totalSize, 0)
+}
+
+export const combineBarSizeList = (
+	allBars: ReadonlyArray<MaybeStackedGraphicalItem>,
+	globalSize: string | number | undefined,
+	totalSize: number | undefined,
+): SizeList => {
+	const initialValue: Record<StackId, Array<DefinitelyStackedGraphicalItem>> = {}
+
+	const stackedBars: ReadonlyArray<DefinitelyStackedGraphicalItem> = allBars.filter(isStacked)
+	const unstackedBars = allBars.filter((b) => b.stackId == null)
+
+	const groupByStack: Record<StackId, Array<DefinitelyStackedGraphicalItem>> = stackedBars.reduce(
+		(acc, bar) => {
+			let s = acc[bar.stackId]
+			if (s == null) {
+				s = []
+			}
+			s.push(bar)
+			acc[bar.stackId] = s
+			return acc
+		},
+		initialValue,
+	)
+
+	const stackedSizeList: SizeList = Object.entries(groupByStack).map(
+		([stackId, bars]): BarCategory => {
+			const dataKeys = bars.map((b) => b.dataKey)
+			const barSize: number | undefined = getBarSize(globalSize, totalSize, bars[0]?.barSize)
+			return { barSize, dataKeys, stackId }
+		},
+	)
+
+	const unstackedSizeList: SizeList = unstackedBars.map((b): BarCategory => {
+		const dataKeys = [b.dataKey].filter((dk) => dk != null)
+		const barSize: number | undefined = getBarSize(globalSize, totalSize, b.barSize)
+		return { barSize, dataKeys, stackId: undefined }
+	})
+
+	return [...stackedSizeList, ...unstackedSizeList]
+}
+
+export type BarCategory = {
+	stackId: StackId | undefined
+	/**
+	 * List of dataKeys of items stacked at this position.
+	 * All of these Bars are either sharing the same stackId,
+	 * or this is an array with one Bar because it has no stackId defined.
+	 *
+	 * This structure limits us to having one dataKey only once per stack which I think is reasonable.
+	 * People who want to have the same data twice can duplicate their data to have two distinct dataKeys.
+	 */
+	dataKeys: ReadonlyArray<DataKey<unknown>>
+	/**
+	 * Width (in horizontal chart) or height (in vertical chart) of this stack of items
+	 */
+	barSize: number | undefined
+}

package/src/state/selectors/combiners/combineCheckedDomain.ts

@@ -0,0 +1,48 @@
+/* eslint-disable import/no-cycle */
+import { CategoricalDomain, NumberDomain } from "../../../util/types"
+import { isWellFormedNumberDomain } from "../../../util/isDomainSpecifiedByUser"
+import { isWellBehavedNumber } from "../../../util/isWellBehavedNumber"
+
+/**
+ * This function validates and transforms the axis domain so that it is safe to use in the provided scale.
+ */
+export const combineCheckedDomain = (
+	realScaleType: string | undefined,
+	axisDomain: NumberDomain | CategoricalDomain | undefined,
+): NumberDomain | CategoricalDomain | undefined => {
+	if (axisDomain == null) {
+		return undefined
+	}
+	switch (realScaleType) {
+		case "linear": {
+			/*
+			 * linear scale only reads the first two numbers in the domain, and ignores everything else.
+			 * So if it happens that someone somehow gave us a bigger domain,
+			 * let's pick the min and max from it.
+			 */
+			if (!isWellFormedNumberDomain(axisDomain)) {
+				let min: number | undefined
+				let max: number | undefined
+				for (let i = 0; i < axisDomain.length; i++) {
+					const value = axisDomain[i]
+					if (!isWellBehavedNumber(value)) {
+						continue
+					}
+					if (min === undefined || value < min) {
+						min = value
+					}
+					if (max === undefined || value > max) {
+						max = value
+					}
+				}
+				if (min !== undefined && max !== undefined) {
+					return [min, max]
+				}
+				return undefined
+			}
+			return axisDomain
+		}
+		default:
+			return axisDomain
+	}
+}

package/src/state/selectors/combiners/combineConfiguredScale.ts

@@ -0,0 +1,111 @@
+/* eslint-disable import/no-cycle */
+import * as d3Scales from "victory-vendor/d3-scale"
+import { BaseCartesianAxis } from "../../cartesianAxisSlice"
+import {
+	CategoricalDomain,
+	CategoricalDomainItem,
+	D3ScaleType,
+	NumberDomain,
+} from "../../../util/types"
+import { CustomScaleDefinition } from "../../../util/scale/CustomScaleDefinition"
+import { AxisRange } from "../axisSelectors"
+import { upperFirst } from "../../../util/DataUtils"
+
+function lookupScale<Domain extends CategoricalDomainItem>(
+	key: string,
+): (() => CustomScaleDefinition<Domain>) | undefined {
+	if (key in d3Scales) {
+		const val: unknown = (d3Scales as Record<string, unknown>)[key]
+		if (typeof val === "function") {
+			return val as () => CustomScaleDefinition<Domain>
+		}
+	}
+	return undefined
+}
+
+function getD3ScaleFromType<Domain extends CategoricalDomainItem = CategoricalDomainItem>(
+	realScaleType: D3ScaleType,
+): CustomScaleDefinition<Domain> | undefined {
+	const direct = lookupScale<Domain>(realScaleType)
+	if (direct != null) {
+		return direct()
+	}
+	const prefixed = lookupScale<Domain>(`scale${upperFirst(realScaleType)}`)
+	if (prefixed != null) {
+		return prefixed()
+	}
+	return undefined
+}
+
+/**
+ * Converts external scale definition into internal RechartsScale definition.
+ * @param scale custom function scale - if you have the `string` from outside, use `combineRealScaleType` first which will validate it and return D3ScaleType or undefined
+ * @param axisDomain
+ * @param axisRange
+ */
+export function combineConfiguredScaleInternal(
+	scale:
+		| CustomScaleDefinition
+		| CustomScaleDefinition<string>
+		| CustomScaleDefinition<number>
+		| CustomScaleDefinition<Date>,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): CustomScaleDefinition
+export function combineConfiguredScaleInternal(
+	scale: D3ScaleType,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): CustomScaleDefinition
+export function combineConfiguredScaleInternal(
+	scale: D3ScaleType | undefined,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): CustomScaleDefinition | undefined
+export function combineConfiguredScaleInternal(
+	scale: undefined,
+	axisDomain: ReadonlyArray<CategoricalDomainItem>,
+	axisRange: AxisRange,
+): undefined
+export function combineConfiguredScaleInternal<
+	Domain extends CategoricalDomainItem = CategoricalDomainItem,
+>(
+	scale: D3ScaleType | CustomScaleDefinition<Domain> | undefined,
+	axisDomain: ReadonlyArray<Domain>,
+	axisRange: AxisRange,
+): CustomScaleDefinition<Domain> | undefined
+export function combineConfiguredScaleInternal<
+	Domain extends CategoricalDomainItem = CategoricalDomainItem,
+>(
+	scale: D3ScaleType | CustomScaleDefinition<Domain> | undefined,
+	axisDomain: ReadonlyArray<Domain>,
+	axisRange: AxisRange,
+): CustomScaleDefinition<Domain> | undefined {
+	if (typeof scale === "function") {
+		return scale.copy().domain(axisDomain).range(axisRange)
+	}
+	if (scale == null) {
+		return undefined
+	}
+	const d3ScaleFunction: CustomScaleDefinition<Domain> | undefined = getD3ScaleFromType(scale)
+	if (d3ScaleFunction == null) {
+		return undefined
+	}
+	d3ScaleFunction.domain(axisDomain).range(axisRange)
+	return d3ScaleFunction
+}
+
+export function combineConfiguredScale(
+	axis: BaseCartesianAxis,
+	realScaleType: D3ScaleType | undefined,
+	axisDomain: NumberDomain | CategoricalDomain | undefined,
+	axisRange: AxisRange | undefined,
+): CustomScaleDefinition | undefined {
+	if (axisDomain == null || axisRange == null) {
+		return undefined
+	}
+	if (typeof axis.scale === "function") {
+		return combineConfiguredScaleInternal(axis.scale, axisDomain, axisRange)
+	}
+	return combineConfiguredScaleInternal(realScaleType, axisDomain, axisRange)
+}

package/src/state/selectors/combiners/combineCoordinateForDefaultIndex.ts

@@ -0,0 +1,45 @@
+/* eslint-disable import/no-cycle */
+import { ChartOffsetInternal, Coordinate, LayoutType, TickItem } from "../../../util/types"
+import { TooltipIndex, TooltipPayloadConfiguration } from "../../tooltipSlice"
+
+export const combineCoordinateForDefaultIndex = (
+	width: number,
+	height: number,
+	layout: LayoutType,
+	offset: ChartOffsetInternal,
+	tooltipTicks: ReadonlyArray<TickItem> | undefined,
+	defaultIndex: TooltipIndex | undefined,
+	tooltipConfigurations: ReadonlyArray<TooltipPayloadConfiguration>,
+): Coordinate | undefined => {
+	if (defaultIndex == null) {
+		return undefined
+	}
+	/*
+	 * With defaultIndex alone, we don't have enough information to decide _which_ of the multiple tooltips to display.
+	 * Maybe one day we could add new prop `activeGraphicalItemId` to the chart to help with that.
+	 * Until then, we choose the first one.
+	 */
+	const firstConfiguration = tooltipConfigurations[0]
+	const maybePosition: Coordinate | undefined = firstConfiguration?.getPosition(defaultIndex)
+	if (maybePosition != null) {
+		return maybePosition
+	}
+	const tick = tooltipTicks?.[Number(defaultIndex)]
+	if (!tick) {
+		return undefined
+	}
+	switch (layout) {
+		case "horizontal": {
+			return {
+				x: tick.coordinate,
+				y: (offset.top + height) / 2,
+			}
+		}
+		default: {
+			return {
+				x: (offset.left + width) / 2,
+				y: tick.coordinate,
+			}
+		}
+	}
+}

package/src/state/selectors/combiners/combineDisplayedStackedData.ts

@@ -0,0 +1,50 @@
+/* eslint-disable import/no-cycle */
+import { ChartDataState } from "../../chartDataSlice"
+import { BaseCartesianAxis } from "../../cartesianAxisSlice"
+import { getStackSeriesIdentifier } from "../../../util/stacks/getStackSeriesIdentifier"
+import { getValueByDataKey } from "../../../util/ChartUtils"
+import { StackSeriesIdentifier } from "../../../util/stacks/stackTypes"
+import { DefinitelyStackedGraphicalItem } from "../../types/StackedGraphicalItem"
+
+/**
+ * In a stacked chart, each graphical item has its own data. That data could be either:
+ * - defined on the chart root, in which case the item gets a unique dataKey
+ * - or defined on the item itself, in which case multiple items can share the same dataKey
+ *
+ * That means we cannot use the dataKey as a unique identifier for the item.
+ *
+ * This type represents a single data point in a stacked chart, where each key is a series identifier
+ * and the value is the numeric value for that series using the numerical axis dataKey.
+ */
+export type DisplayedStackedDataPoint = Record<StackSeriesIdentifier, number>
+
+export type DisplayedStackedData = ReadonlyArray<DisplayedStackedDataPoint>
+
+export function combineDisplayedStackedData(
+	stackedGraphicalItems: ReadonlyArray<DefinitelyStackedGraphicalItem>,
+	{ chartData = [] }: ChartDataState,
+	tooltipAxisSettings: BaseCartesianAxis,
+): DisplayedStackedData {
+	const { allowDuplicatedCategory, dataKey: tooltipDataKey } = tooltipAxisSettings
+
+	const knownItemsByDataKey = new Map<string | number, DisplayedStackedDataPoint>()
+
+	stackedGraphicalItems.forEach((item) => {
+		const resolvedData = item.data ?? chartData
+		if (resolvedData == null || resolvedData.length === 0) {
+			return
+		}
+		const stackIdentifier = getStackSeriesIdentifier(item)
+		resolvedData.forEach((entry, index) => {
+			const tooltipValue =
+				tooltipDataKey == null || allowDuplicatedCategory
+					? index
+					: String(getValueByDataKey(entry, tooltipDataKey, null))
+			const numericValue = getValueByDataKey(entry, item.dataKey, 0)
+			const curr = knownItemsByDataKey.get(tooltipValue) ?? {}
+			Object.assign(curr, { [stackIdentifier]: numericValue })
+			knownItemsByDataKey.set(tooltipValue, curr as DisplayedStackedDataPoint)
+		})
+	})
+	return Array.from(knownItemsByDataKey.values())
+}

package/src/state/selectors/combiners/combineInverseScaleFunction.ts

@@ -0,0 +1,16 @@
+/* eslint-disable import/no-cycle */
+import { InverseScaleFunction } from "../../../hooks"
+import { createCategoricalInverse } from "../../../util/scale/createCategoricalInverse"
+import { CustomScaleDefinition } from "../../../util/scale/CustomScaleDefinition"
+
+export function combineInverseScaleFunction(
+	configuredScale: CustomScaleDefinition | undefined,
+): InverseScaleFunction | undefined {
+	if (configuredScale == null) {
+		return undefined
+	}
+	if ("invert" in configuredScale && typeof configuredScale.invert === "function") {
+		return configuredScale.invert.bind(configuredScale)
+	}
+	return createCategoricalInverse(configuredScale, undefined)
+}

package/src/state/selectors/combiners/combineRealScaleType.ts

@@ -0,0 +1,44 @@
+/* eslint-disable import/no-cycle */
+import * as d3Scales from "victory-vendor/d3-scale"
+import type { RechartsScaleType } from "../../../util/types"
+import { BaseCartesianAxis } from "../../cartesianAxisSlice"
+import { upperFirst } from "../../../util/DataUtils"
+
+function getD3ScaleName(name: string): string {
+	return `scale${upperFirst(name)}`
+}
+
+function isSupportedScaleName(name: string): name is RechartsScaleType {
+	return getD3ScaleName(name) in d3Scales
+}
+
+export const combineRealScaleType = (
+	axisConfig: BaseCartesianAxis | undefined,
+	hasBar: boolean,
+	chartType: string,
+): RechartsScaleType | undefined => {
+	if (axisConfig == null) {
+		return undefined
+	}
+	const { scale, type } = axisConfig
+	if (scale === "auto") {
+		if (
+			type === "category" &&
+			chartType &&
+			(chartType.indexOf("LineChart") >= 0 ||
+				chartType.indexOf("AreaChart") >= 0 ||
+				(chartType.indexOf("ComposedChart") >= 0 && !hasBar))
+		) {
+			return "point"
+		}
+		if (type === "category") {
+			return "band"
+		}
+
+		return "linear"
+	}
+	if (typeof scale === "string") {
+		return isSupportedScaleName(scale) ? scale : "point"
+	}
+	return undefined
+}

package/src/state/selectors/combiners/combineStackedData.ts

@@ -0,0 +1,27 @@
+/* eslint-disable import/no-cycle */
+import { AllStackGroups, StackGroup, StackSeries } from "../../../util/stacks/stackTypes"
+import { MaybeStackedGraphicalItem } from "../../types/StackedGraphicalItem"
+import { getStackSeriesIdentifier } from "../../../util/stacks/getStackSeriesIdentifier"
+
+export const combineStackedData = (
+	stackGroups: AllStackGroups | undefined,
+	barSettings: MaybeStackedGraphicalItem | undefined,
+): StackSeries | undefined => {
+	const stackSeriesIdentifier = getStackSeriesIdentifier(barSettings)
+	if (!stackGroups || stackSeriesIdentifier == null || barSettings == null) {
+		return undefined
+	}
+	const { stackId } = barSettings
+	if (stackId == null) {
+		return undefined
+	}
+	const stackGroup: StackGroup | undefined = stackGroups[stackId]
+	if (!stackGroup) {
+		return undefined
+	}
+	const { stackedData }: StackGroup = stackGroup
+	if (!stackedData) {
+		return undefined
+	}
+	return stackedData.find((sd) => sd.key === stackSeriesIdentifier)
+}