@solidports/recharts 0.1.0 → 0.1.1

package/src/util/scale/createCategoricalInverse.ts

@@ -1,72 +0,0 @@
-/* eslint-disable import/no-cycle */
-import { InverseScaleFunction } from "../../hooks"
-import { CustomScaleDefinition } from "./CustomScaleDefinition"
-
-/**
- * Binary search to find the index where x would fit in array a.
- * Works for arrays that are sorted both ascending and descending.
- *
- * Unlike d3.bisect, this implementation handles both ascending and descending arrays.
- *
- * @param haystack Sorted array of numbers
- * @param needle Number to find the insertion index for
- * @returns Index where x would fit in array a
- */
-export function bisect(haystack: ReadonlyArray<number>, needle: number): number {
-	let lo = 0
-	let hi = haystack.length
-	const first = haystack[0] ?? 0
-	const last = haystack[haystack.length - 1] ?? 0
-	const ascending = first < last
-
-	while (lo < hi) {
-		const mid = Math.floor((lo + hi) / 2)
-		const midVal = haystack[mid] ?? 0
-		if (ascending ? midVal < needle : midVal > needle) {
-			lo = mid + 1
-		} else {
-			hi = mid
-		}
-	}
-	return lo
-}
-
-/**
- * Computes an inverse scale function for categorical/ordinal scales.
- * Uses bisect to find the closest domain value for a given pixel coordinate.
- */
-export function createCategoricalInverse(
-	scale: CustomScaleDefinition | undefined,
-	allDataPointsOnAxis?: ReadonlyArray<unknown>,
-): InverseScaleFunction | undefined {
-	if (!scale) {
-		return undefined
-	}
-	const domain = allDataPointsOnAxis ?? scale.domain()
-	const pixelPositions: number[] = domain.map(
-		(d) => (scale as (input: unknown) => number | undefined)(d) ?? 0,
-	)
-	const range = scale.range()
-
-	if (domain.length === 0 || range.length < 2) {
-		return undefined
-	}
-
-	return (pixelValue: number): unknown => {
-		const index = bisect(pixelPositions, pixelValue)
-
-		if (index <= 0) {
-			return domain[0]
-		}
-		if (index >= domain.length) {
-			return domain[domain.length - 1]
-		}
-
-		const leftPixel = pixelPositions[index - 1] ?? 0
-		const rightPixel = pixelPositions[index] ?? 0
-		if (Math.abs(pixelValue - leftPixel) <= Math.abs(pixelValue - rightPixel)) {
-			return domain[index - 1]
-		}
-		return domain[index]
-	}
-}

package/src/util/scale/getNiceTickValues.ts

@@ -1,311 +0,0 @@
-/* eslint-disable import/no-cycle */
-/**
- * @fileOverview calculate tick values of scale
- * @author xile611, arcthur
- * @date 2015-09-17
- */
-import Decimal from "decimal.js-light"
-import { getDigitCount, rangeStep } from "./util/arithmetic"
-import type { NumberDomain } from "../types"
-import type { NiceTicksAlgorithm } from "../../state/cartesianAxisSlice"
-
-/**
- * Calculate a interval of a minimum value and a maximum value
- *
- * @param  {Number} min       The minimum value
- * @param  {Number} max       The maximum value
- * @return {Array} An interval
- */
-export const getValidInterval = ([min, max]: [number, number]): [number, number] => {
-	let [validMin, validMax] = [min, max]
-
-	// exchange
-	if (min > max) {
-		[validMin, validMax] = [max, min]
-	}
-
-	return [validMin, validMax]
-}
-
-/**
- * Calculate the step which is easy to understand between ticks, like 10, 20, 25
- *
- * @param  roughStep        The rough step calculated by dividing the difference by the tickCount
- * @param  allowDecimals    Allow the ticks to be decimals or not
- * @param  correctionFactor A correction factor
- * @return The step which is easy to understand between two ticks
- */
-export const getAdaptiveStep = (roughStep: Decimal, allowDecimals: boolean, correctionFactor: number) => {
-	if (roughStep.lte(0)) {
-		return new Decimal(0)
-	}
-
-	const digitCount = getDigitCount(roughStep.toNumber())
-	// The ratio between the rough step and the smallest number which has a bigger
-	// order of magnitudes than the rough step
-	const digitCountValue = new Decimal(10).pow(digitCount)
-	const stepRatio = roughStep.div(digitCountValue)
-	// When an integer and a float multiplied, the accuracy of result may be wrong
-	const stepRatioScale = digitCount !== 1 ? 0.05 : 0.1
-	const amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber()))
-		.add(correctionFactor)
-		.mul(stepRatioScale)
-
-	const formatStep = amendStepRatio.mul(digitCountValue)
-
-	return allowDecimals ? new Decimal(formatStep.toNumber()) : new Decimal(Math.ceil(formatStep.toNumber()))
-}
-
-type StepFunction = (roughStep: Decimal, allowDecimals: boolean, correctionFactor: number) => Decimal
-
-/**
- * The snap125 step algorithm snaps to nice numbers (1, 2, 2.5, 5) at each
- * order of magnitude, producing human-friendly tick intervals like
- * 0, 5, 10, 15, 20 instead of 0, 4, 8, 12, 16.
- *
- * This is opt-in and can be enabled via the `niceTicks` prop on axis components.
- *
- * @param  roughStep        The rough step calculated by dividing the difference by the tickCount
- * @param  allowDecimals    Allow the ticks to be decimals or not
- * @param  correctionFactor A correction factor
- * @return The step which is easy to understand between two ticks
- */
-export const getSnap125Step: StepFunction = (roughStep: Decimal, allowDecimals: boolean, correctionFactor: number) => {
-	if (roughStep.lte(0)) {
-		return new Decimal(0)
-	}
-
-	const NICE_STEPS = [1, 2, 2.5, 5]
-
-	const roughNum = roughStep.toNumber()
-	const exponent = Math.floor(new Decimal(roughNum).abs().log(10).toNumber())
-	let magnitude = new Decimal(10).pow(exponent)
-
-	// normalized is in the range [1, 10)
-	const normalized = roughStep.div(magnitude).toNumber()
-
-	// Find the smallest nice step >= normalized (ceiling)
-	let niceIdx = NICE_STEPS.findIndex(s => s >= normalized - 1e-10)
-	if (niceIdx === -1) {
-		// normalized > 5 (e.g. 7.3), move to next order of magnitude
-		magnitude = magnitude.mul(10)
-		niceIdx = 0
-	}
-
-	// Apply correction factor by stepping through the nice number sequence
-	niceIdx += correctionFactor
-	if (niceIdx >= NICE_STEPS.length) {
-		const extraMag = Math.floor(niceIdx / NICE_STEPS.length)
-		niceIdx %= NICE_STEPS.length
-		magnitude = magnitude.mul(new Decimal(10).pow(extraMag))
-	}
-
-	const niceStep = NICE_STEPS[niceIdx] ?? 1
-	const formatStep = new Decimal(niceStep).mul(magnitude)
-
-	return allowDecimals ? formatStep : new Decimal(Math.ceil(formatStep.toNumber()))
-}
-
-/**
- * calculate the ticks when the minimum value equals to the maximum value
- *
- * @param  value         The minimum value which is also the maximum value
- * @param  tickCount     The count of ticks
- * @param  allowDecimals Allow the ticks to be decimals or not
- * @return array of ticks
- */
-export const getTickOfSingleValue = (value: number, tickCount: number, allowDecimals: boolean): Array<number> => {
-	let step: Decimal = new Decimal(1)
-	// calculate the middle value of ticks
-	let middle = new Decimal(value)
-
-	if (!middle.isint() && allowDecimals) {
-		const absVal = Math.abs(value)
-
-		if (absVal < 1) {
-			// The step should be a float number when the difference is smaller than 1
-			step = new Decimal(10).pow(getDigitCount(value) - 1)
-
-			middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step)
-		} else if (absVal > 1) {
-			// Return the maximum integer which is smaller than 'value' when 'value' is greater than 1
-			middle = new Decimal(Math.floor(value))
-		}
-	} else if (value === 0) {
-		middle = new Decimal(Math.floor((tickCount - 1) / 2))
-	} else if (!allowDecimals) {
-		middle = new Decimal(Math.floor(value))
-	}
-
-	const middleIndex = Math.floor((tickCount - 1) / 2)
-	const ticks: Array<number> = []
-
-	for (let i = 0; i < tickCount; i++) {
-		ticks.push(middle.add(new Decimal(i - middleIndex).mul(step)).toNumber())
-	}
-
-	return ticks
-}
-
-/**
- * Calculate the step
- *
- * @param  min              The minimum value of an interval
- * @param  max              The maximum value of an interval
- * @param  tickCount        The count of ticks
- * @param  allowDecimals    Allow the ticks to be decimals or not
- * @param  correctionFactor A correction factor
- * @return The step, minimum value of ticks, maximum value of ticks
- */
-export const calculateStep = (
-	min: number,
-	max: number,
-	tickCount: number,
-	allowDecimals: boolean,
-	correctionFactor: number = 0,
-	stepFn: StepFunction = getAdaptiveStep,
-): {
-	step: Decimal
-	tickMin: Decimal
-	tickMax: Decimal
-} => {
-	// dirty hack (for recharts' test)
-	if (!Number.isFinite((max - min) / (tickCount - 1))) {
-		return {
-			step: new Decimal(0),
-			tickMin: new Decimal(0),
-			tickMax: new Decimal(0),
-		}
-	}
-
-	// The step which is easy to understand between two ticks
-	const step = stepFn(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor)
-
-	// A medial value of ticks
-	let middle
-
-	// When 0 is inside the interval, 0 should be a tick
-	if (min <= 0 && max >= 0) {
-		middle = new Decimal(0)
-	} else {
-		// calculate the middle value
-		middle = new Decimal(min).add(max).div(2)
-		// minus modulo value
-		middle = middle.sub(new Decimal(middle).mod(step))
-	}
-
-	let belowCount = Math.ceil(middle.sub(min).div(step).toNumber())
-	let upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber())
-	const scaleCount = belowCount + upCount + 1
-
-	if (scaleCount > tickCount) {
-		// When more ticks need to cover the interval, step should be bigger.
-		return calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1, stepFn)
-	}
-	if (scaleCount < tickCount) {
-		// When less ticks can cover the interval, we should add some additional ticks
-		upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount
-		belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount)
-	}
-
-	return {
-		step,
-		tickMin: middle.sub(new Decimal(belowCount).mul(step)),
-		tickMax: middle.add(new Decimal(upCount).mul(step)),
-	}
-}
-
-/**
- * Calculate the ticks of an interval. Ticks can appear outside the interval
- * if it makes them more rounded and nice.
- *
- * @param tuple of [min,max] min: The minimum value, max: The maximum value
- * @param tickCount     The count of ticks
- * @param allowDecimals Allow the ticks to be decimals or not
- * @param niceTicksMode The algorithm to use for calculating nice ticks.
- * @return array of ticks
- */
-export const getNiceTickValues = (
-	[min, max]: NumberDomain,
-	tickCount = 6,
-	allowDecimals = true,
-	niceTicksMode: NiceTicksAlgorithm = "auto",
-): number[] => {
-	// More than two ticks should be return
-	const count = Math.max(tickCount, 2)
-	const [cormin, cormax] = getValidInterval([min, max])
-
-	if (cormin === -Infinity || cormax === Infinity) {
-		const values: Array<number> =
-			cormax === Infinity
-				? [cormin, ...Array(tickCount - 1).fill(Infinity)]
-				: [...Array(tickCount - 1).fill(-Infinity), cormax]
-
-		return min > max ? values.reverse() : values
-	}
-
-	if (cormin === cormax) {
-		return getTickOfSingleValue(cormin, tickCount, allowDecimals)
-	}
-
-	const stepFn = niceTicksMode === "snap125" ? getSnap125Step : getAdaptiveStep
-
-	// Get the step between two ticks
-	const { step, tickMin, tickMax } = calculateStep(cormin, cormax, count, allowDecimals, 0, stepFn)
-
-	const values = rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step)
-
-	return min > max ? values.reverse() : values
-}
-
-/**
- * Calculate the ticks of an interval.
- * Ticks will be constrained to the interval [min, max] even if it makes them less rounded and nice.
- *
- * @param tuple of [min,max] min: The minimum value, max: The maximum value
- * @param tickCount     The count of ticks. This function may return less than tickCount ticks if the interval is too small.
- * @param allowDecimals Allow the ticks to be decimals or not
- * @param niceTicksMode          The algorithm to use for calculating nice ticks. See {@link NiceTicksAlgorithm}.
- * @return array of ticks
- */
-export const getTickValuesFixedDomain = (
-	[min, max]: NumberDomain,
-	tickCount: number,
-	allowDecimals = true,
-	niceTicksMode: NiceTicksAlgorithm = "auto",
-) => {
-	// More than two ticks should be return
-	const [cormin, cormax] = getValidInterval([min, max])
-
-	if (cormin === -Infinity || cormax === Infinity) {
-		return [min, max]
-	}
-
-	if (cormin === cormax) {
-		return [cormin]
-	}
-
-	const stepFn = niceTicksMode === "snap125" ? getSnap125Step : getAdaptiveStep
-	const count = Math.max(tickCount, 2)
-	const step = stepFn(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0)
-	let values = [...rangeStep(new Decimal(cormin), new Decimal(cormax), step), cormax]
-
-	if (allowDecimals === false) {
-		/*
-		 * allowDecimals is false means that we want to have integer ticks.
-		 * The step is guaranteed to be an integer in the code above which is great start
-		 * but when the first step is not an integer, it will start stepping from a decimal value anyway.
-		 * So we need to round all the values to integers after the fact.
-		 * The domain boundary (cormax) is appended after the rangeStep values. When
-		 * cormax rounds down to the same integer as the last rangeStep value, we end up
-		 * with a duplicate trailing tick. Remove it.
-		 */
-		values = values.map(value => Math.round(value))
-		const last = values.length - 1
-		if (last > 0 && values[last] === values[last - 1]) {
-			values = values.slice(0, last)
-		}
-	}
-
-	return min > max ? values.reverse() : values
-}

package/src/util/scale/index.ts

@@ -1,2 +0,0 @@
-/* eslint-disable import/no-cycle */
-export { getNiceTickValues, getTickValuesFixedDomain } from "./getNiceTickValues"

package/src/util/scale/util/arithmetic.ts

@@ -1,54 +0,0 @@
-/**
- * @fileOverview Some common arithmetic methods
- * @author xile611
- * @date 2015-09-17
- */
-import Decimal from "decimal.js-light"
-
-/**
- * Get the digit count of a number.
- * If the absolute value is in the interval [0.1, 1), the result is 0.
- * If the absolute value is in the interval [0.01, 0.1), the digit count is -1.
- * If the absolute value is in the interval [0.001, 0.01), the digit count is -2.
- *
- * @param  {Number} value The number
- * @return {Integer}      Digit count
- */
-function getDigitCount(value: number) {
-	let result
-
-	if (value === 0) {
-		result = 1
-	} else {
-		result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1
-	}
-
-	return result
-}
-
-/**
- * Get the data in the interval [start, end) with a fixed step.
- * Also handles JS calculation precision issues.
- *
- * @param  {Decimal} start Start point
- * @param  {Decimal} end   End point, not included
- * @param  {Decimal} step  Step size
- * @return {Array}         Array of numbers
- */
-function rangeStep(start: Decimal, end: Decimal, step: Decimal): Array<number> {
-	let num = new Decimal(start)
-	let i = 0
-	const result: Array<number> = []
-
-	/* magic number to prevent infinite loop */
-	while (num.lt(end) && i < 100000) {
-		result.push(num.toNumber())
-
-		num = num.add(step)
-		i++
-	}
-
-	return result
-}
-
-export { rangeStep, getDigitCount }