@solidports/recharts 0.1.0 → 0.1.1

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

@@ -1,95 +0,0 @@
-/* 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

@@ -1,122 +0,0 @@
-/* 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

@@ -1,16 +0,0 @@
-/* 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

@@ -1,23 +0,0 @@
-/* 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

@@ -1,80 +0,0 @@
-/* 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

@@ -1,48 +0,0 @@
-/* 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

@@ -1,111 +0,0 @@
-/* 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

@@ -1,45 +0,0 @@
-/* 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

@@ -1,50 +0,0 @@
-/* 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

@@ -1,16 +0,0 @@
-/* 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

@@ -1,44 +0,0 @@
-/* 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

@@ -1,27 +0,0 @@
-/* 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)
-}