vccs 0.6.0 → 1.0.0-beta.2

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

@@ -1,167 +0,0 @@
-import { selectChartHeight, selectChartWidth } from "./containerSelectors.mjs";
-import { getPercentValue } from "../../utils/data.mjs";
-import { selectChartOffset } from "./selectChartOffset.mjs";
-import { combineAxisRangeWithReverse } from "./combiners/combineAxisRangeWithReverse.mjs";
-import { getMaxRadius } from "../../utils/polar.mjs";
-import { selectChartLayout } from "./common.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/polarAxisSelectors.ts
-var defaultPolarAngleAxisProps = {
-	allowDuplicatedCategory: true,
-	angleAxisId: 0,
-	axisLine: true,
-	cx: 0,
-	cy: 0,
-	orientation: "outer",
-	reversed: false,
-	scale: "auto",
-	tick: true,
-	tickLine: true,
-	tickSize: 8,
-	type: "category"
-};
-var implicitAngleAxis = {
-	allowDataOverflow: false,
-	allowDecimals: false,
-	allowDuplicatedCategory: false,
-	dataKey: void 0,
-	domain: void 0,
-	id: void 0,
-	includeHidden: false,
-	name: void 0,
-	reversed: defaultPolarAngleAxisProps.reversed,
-	scale: defaultPolarAngleAxisProps.scale,
-	tick: defaultPolarAngleAxisProps.tick,
-	tickCount: void 0,
-	ticks: void 0,
-	type: defaultPolarAngleAxisProps.type,
-	unit: void 0
-};
-var defaultPolarRadiusAxisProps = {
-	allowDataOverflow: false,
-	allowDuplicatedCategory: true,
-	angle: 0,
-	axisLine: true,
-	cx: 0,
-	cy: 0,
-	orientation: "right",
-	radiusAxisId: 0,
-	scale: "auto",
-	stroke: "#ccc",
-	tick: true,
-	tickCount: 5,
-	type: "number"
-};
-var implicitRadiusAxis = {
-	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
-	allowDecimals: false,
-	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
-	dataKey: void 0,
-	domain: void 0,
-	id: void 0,
-	includeHidden: false,
-	name: void 0,
-	reversed: false,
-	scale: defaultPolarRadiusAxisProps.scale,
-	tick: defaultPolarRadiusAxisProps.tick,
-	tickCount: defaultPolarRadiusAxisProps.tickCount,
-	ticks: void 0,
-	type: defaultPolarRadiusAxisProps.type,
-	unit: void 0
-};
-var implicitRadialBarAngleAxis = {
-	allowDataOverflow: false,
-	allowDecimals: false,
-	allowDuplicatedCategory: defaultPolarAngleAxisProps.allowDuplicatedCategory,
-	dataKey: void 0,
-	domain: void 0,
-	id: void 0,
-	includeHidden: false,
-	name: void 0,
-	reversed: false,
-	scale: defaultPolarAngleAxisProps.scale,
-	tick: defaultPolarAngleAxisProps.tick,
-	tickCount: void 0,
-	ticks: void 0,
-	type: "number",
-	unit: void 0
-};
-var implicitRadialBarRadiusAxis = {
-	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
-	allowDecimals: false,
-	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
-	dataKey: void 0,
-	domain: void 0,
-	id: void 0,
-	includeHidden: false,
-	name: void 0,
-	reversed: false,
-	scale: defaultPolarRadiusAxisProps.scale,
-	tick: defaultPolarRadiusAxisProps.tick,
-	tickCount: defaultPolarRadiusAxisProps.tickCount,
-	ticks: void 0,
-	type: "category",
-	unit: void 0
-};
-function selectAngleAxis(state, angleAxisId) {
-	if (state.polarAxis.angleAxis[angleAxisId] != null) return state.polarAxis.angleAxis[angleAxisId];
-	if (state.layout.layoutType === "radial") return implicitRadialBarAngleAxis;
-	return implicitAngleAxis;
-}
-function selectRadiusAxis(state, radiusAxisId) {
-	if (state.polarAxis.radiusAxis[radiusAxisId] != null) return state.polarAxis.radiusAxis[radiusAxisId];
-	if (state.layout.layoutType === "radial") return implicitRadialBarRadiusAxis;
-	return implicitRadiusAxis;
-}
-var selectPolarOptions = (state) => state.polarOptions;
-var selectMaxRadius = createSelector([
-	selectChartWidth,
-	selectChartHeight,
-	selectChartOffset
-], getMaxRadius);
-var selectInnerRadius = createSelector([selectPolarOptions, selectMaxRadius], (polarChartOptions, maxRadius) => {
-	if (polarChartOptions == null) return;
-	return getPercentValue(polarChartOptions.innerRadius, maxRadius, 0);
-});
-var selectOuterRadius = createSelector([selectPolarOptions, selectMaxRadius], (polarChartOptions, maxRadius) => {
-	if (polarChartOptions == null) return;
-	return getPercentValue(polarChartOptions.outerRadius, maxRadius, maxRadius * .8);
-});
-function combineAngleAxisRange(polarOptions) {
-	if (polarOptions == null) return [0, 0];
-	const { startAngle, endAngle } = polarOptions;
-	return [startAngle, endAngle];
-}
-var selectAngleAxisRange = createSelector([selectPolarOptions], combineAngleAxisRange);
-var selectAngleAxisRangeWithReversed = createSelector([selectAngleAxis, selectAngleAxisRange], combineAxisRangeWithReverse);
-var selectRadiusAxisRange = createSelector([
-	selectMaxRadius,
-	selectInnerRadius,
-	selectOuterRadius
-], (maxRadius, innerRadius, outerRadius) => {
-	if (maxRadius == null || innerRadius == null || outerRadius == null) return;
-	return [innerRadius, outerRadius];
-});
-var selectRadiusAxisRangeWithReversed = createSelector([selectRadiusAxis, selectRadiusAxisRange], combineAxisRangeWithReverse);
-var selectPolarViewBox = createSelector([
-	selectChartLayout,
-	selectPolarOptions,
-	selectInnerRadius,
-	selectOuterRadius,
-	selectChartWidth,
-	selectChartHeight
-], (layout, polarOptions, innerRadius, outerRadius, width, height) => {
-	if (layout !== "centric" && layout !== "radial" || polarOptions == null || innerRadius == null || outerRadius == null) return;
-	const { cx, cy, startAngle, endAngle } = polarOptions;
-	return {
-		cx: getPercentValue(cx, width, width / 2),
-		cy: getPercentValue(cy, height, height / 2),
-		innerRadius,
-		outerRadius,
-		startAngle,
-		endAngle,
-		clockWise: false
-	};
-});
-//#endregion
-export { selectAngleAxis, selectAngleAxisRange, selectAngleAxisRangeWithReversed, selectPolarViewBox, selectRadiusAxis, selectRadiusAxisRange, selectRadiusAxisRangeWithReversed };

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

@@ -1,19 +0,0 @@
-import { selectPolarAxisTicks } from "./polarScaleSelectors.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/polarGridSelectors.ts
-function selectAngleAxisTicks(state, anglexisId) {
-	return selectPolarAxisTicks(state, "angleAxis", anglexisId, false);
-}
-var selectPolarGridAngles = createSelector([selectAngleAxisTicks], (ticks) => {
-	if (!ticks) return;
-	return ticks.map((tick) => tick.coordinate);
-});
-function selectRadiusAxisTicks(state, radiusAxisId) {
-	return selectPolarAxisTicks(state, "radiusAxis", radiusAxisId, false);
-}
-var selectPolarGridRadii = createSelector([selectRadiusAxisTicks], (ticks) => {
-	if (!ticks) return;
-	return ticks.map((tick) => tick.coordinate);
-});
-//#endregion
-export { selectPolarGridAngles, selectPolarGridRadii };

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

@@ -1,55 +0,0 @@
-import { selectChartLayout } from "./common.mjs";
-import { selectAngleAxis, selectAngleAxisRangeWithReversed, selectRadiusAxis, selectRadiusAxisRangeWithReversed } from "./polarAxisSelectors.mjs";
-import { pickAxisType } from "./pickAxisType.mjs";
-import { combineAxisTicks, combineCategoricalDomain, combineGraphicalItemTicks, combineScaleFunction, selectAxisSettings, selectDuplicateDomain, selectRealScaleType } from "./axisSelectors.mjs";
-import { selectPolarAppliedValues, selectPolarAxisDomainIncludingNiceTicks, selectPolarNiceTicks } from "./polarSelectors.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/polarScaleSelectors.ts
-function selectPolarAxis(state, axisType, axisId) {
-	switch (axisType) {
-		case "angleAxis": return selectAngleAxis(state, axisId);
-		case "radiusAxis": return selectRadiusAxis(state, axisId);
-		default: throw new Error(`Unexpected axis type: ${axisType}`);
-	}
-}
-function selectPolarAxisRangeWithReversed(state, axisType, axisId) {
-	switch (axisType) {
-		case "angleAxis": return selectAngleAxisRangeWithReversed(state, axisId);
-		case "radiusAxis": return selectRadiusAxisRangeWithReversed(state, axisId);
-		default: throw new Error(`Unexpected axis type: ${axisType}`);
-	}
-}
-var selectPolarAxisScale = createSelector([
-	selectPolarAxis,
-	selectRealScaleType,
-	selectPolarAxisDomainIncludingNiceTicks,
-	selectPolarAxisRangeWithReversed
-], combineScaleFunction);
-var selectPolarCategoricalDomain = createSelector([
-	selectChartLayout,
-	selectPolarAppliedValues,
-	selectAxisSettings,
-	pickAxisType
-], combineCategoricalDomain);
-var selectPolarAxisTicks = createSelector([
-	selectChartLayout,
-	selectPolarAxis,
-	selectRealScaleType,
-	selectPolarAxisScale,
-	selectPolarNiceTicks,
-	selectPolarAxisRangeWithReversed,
-	selectDuplicateDomain,
-	selectPolarCategoricalDomain,
-	pickAxisType
-], combineAxisTicks);
-var selectPolarGraphicalItemAxisTicks = createSelector([
-	selectChartLayout,
-	selectPolarAxis,
-	selectPolarAxisScale,
-	selectPolarAxisRangeWithReversed,
-	selectDuplicateDomain,
-	selectPolarCategoricalDomain,
-	pickAxisType
-], combineGraphicalItemTicks);
-//#endregion
-export { selectPolarAxisScale, selectPolarAxisTicks, selectPolarGraphicalItemAxisTicks };

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

@@ -1,81 +0,0 @@
-import { selectChartDataAndAlwaysIgnoreIndexes, selectChartDataWithIndexes } from "./dataSelectors.mjs";
-import { selectStackOffsetType } from "./rootPropsSelectors.mjs";
-import { selectChartLayout } from "./common.mjs";
-import { pickAxisType } from "./pickAxisType.mjs";
-import { pickAxisId } from "./pickAxisId.mjs";
-import { getValueByDataKey } from "../../utils/chart.mjs";
-import { combineAppliedValues, combineAxisDomain, combineAxisDomainWithNiceTicks, combineDisplayedData, combineDomainOfStackGroups, combineGraphicalItemsData, combineGraphicalItemsSettings, combineNiceTicks, combineNumericalDomain, combineStackGroups, itemAxisPredicate, selectBaseAxis, selectDomainDefinition, selectRealScaleType } from "./axisSelectors.mjs";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/polarSelectors.ts
-var selectUnfilteredPolarItems = (state) => state.graphicalItems.polarItems;
-var selectPolarItemsSettings = createSelector([
-	selectUnfilteredPolarItems,
-	selectBaseAxis,
-	createSelector([pickAxisType, pickAxisId], itemAxisPredicate)
-], combineGraphicalItemsSettings);
-var selectPolarDisplayedData = createSelector([createSelector([selectPolarItemsSettings], combineGraphicalItemsData), selectChartDataAndAlwaysIgnoreIndexes], combineDisplayedData);
-var selectPolarAppliedValues = createSelector([
-	selectPolarDisplayedData,
-	selectBaseAxis,
-	selectPolarItemsSettings
-], combineAppliedValues);
-var selectAllPolarAppliedNumericalValues = createSelector([
-	selectPolarDisplayedData,
-	selectBaseAxis,
-	selectPolarItemsSettings
-], (data, axisSettings, items) => {
-	if (items.length > 0) return data.flatMap((entry) => {
-		return items.flatMap((item) => {
-			return {
-				value: getValueByDataKey(entry, axisSettings.dataKey ?? item.dataKey),
-				errorDomain: []
-			};
-		});
-	}).filter(Boolean);
-	if (axisSettings?.dataKey != null) return data.map((item) => ({
-		value: getValueByDataKey(item, axisSettings.dataKey),
-		errorDomain: []
-	}));
-	return data.map((entry) => ({
-		value: entry,
-		errorDomain: []
-	}));
-});
-var selectPolarDomainOfStackGroups = createSelector([
-	createSelector([
-		selectPolarDisplayedData,
-		selectPolarItemsSettings,
-		selectStackOffsetType
-	], combineStackGroups),
-	selectChartDataWithIndexes,
-	pickAxisType
-], combineDomainOfStackGroups);
-var unsupportedInPolarChart = () => void 0;
-var selectPolarAxisDomain = createSelector([
-	selectBaseAxis,
-	selectChartLayout,
-	selectPolarDisplayedData,
-	selectPolarAppliedValues,
-	selectStackOffsetType,
-	pickAxisType,
-	createSelector([
-		selectBaseAxis,
-		selectDomainDefinition,
-		selectPolarDomainOfStackGroups,
-		selectAllPolarAppliedNumericalValues,
-		unsupportedInPolarChart
-	], combineNumericalDomain)
-], combineAxisDomain);
-var selectPolarNiceTicks = createSelector([
-	selectPolarAxisDomain,
-	selectBaseAxis,
-	selectRealScaleType
-], combineNiceTicks);
-var selectPolarAxisDomainIncludingNiceTicks = createSelector([
-	selectBaseAxis,
-	selectPolarAxisDomain,
-	selectPolarNiceTicks,
-	pickAxisType
-], combineAxisDomainWithNiceTicks);
-//#endregion
-export { selectPolarAppliedValues, selectPolarAxisDomainIncludingNiceTicks, selectPolarDisplayedData, selectPolarItemsSettings, selectPolarNiceTicks, selectUnfilteredPolarItems };

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

@@ -1,133 +0,0 @@
-import { isCategoricalAxis, isNullish } from "../../utils/validate.mjs";
-import { selectChartDataAndAlwaysIgnoreIndexes } from "./dataSelectors.mjs";
-import { polarToCartesian } from "../../utils/polar.mjs";
-import { selectChartLayout } from "./common.mjs";
-import { selectAngleAxis, selectPolarViewBox, selectRadiusAxis } from "./polarAxisSelectors.mjs";
-import { getBandSizeOfAxis, getValueByDataKey } from "../../utils/chart.mjs";
-import { selectUnfilteredPolarItems } from "./polarSelectors.mjs";
-import { selectPolarAxisScale, selectPolarAxisTicks } from "./polarScaleSelectors.mjs";
-import { last } from "es-toolkit/compat";
-import { createSelector } from "@reduxjs/toolkit";
-//#region src/state/selectors/radarSelectors.ts
-function selectRadiusAxisScale(state, radiusAxisId) {
-	return selectPolarAxisScale(state, "radiusAxis", radiusAxisId);
-}
-var selectRadiusAxisForRadar = createSelector([selectRadiusAxisScale], (scale) => {
-	if (scale == null) return;
-	return { scale };
-});
-var selectRadiusAxisForBandSize = createSelector([selectRadiusAxis, selectRadiusAxisScale], (axisSettings, scale) => {
-	if (axisSettings == null || scale == null) return;
-	return {
-		...axisSettings,
-		scale
-	};
-});
-function selectRadiusAxisTicks(state, radiusAxisId, _angleAxisId, isPanorama) {
-	return selectPolarAxisTicks(state, "radiusAxis", radiusAxisId, isPanorama);
-}
-function selectAngleAxisForRadar(state, _radiusAxisId, angleAxisId) {
-	return selectAngleAxis(state, angleAxisId);
-}
-function selectPolarAxisScaleForRadar(state, _radiusAxisId, angleAxisId) {
-	return selectPolarAxisScale(state, "angleAxis", angleAxisId);
-}
-var selectAngleAxisForBandSize = createSelector([selectAngleAxisForRadar, selectPolarAxisScaleForRadar], (axisSettings, scale) => {
-	if (axisSettings == null || scale == null) return;
-	return {
-		...axisSettings,
-		scale
-	};
-});
-function selectAngleAxisTicks(state, _radiusAxisId, angleAxisId, isPanorama) {
-	return selectPolarAxisTicks(state, "angleAxis", angleAxisId, isPanorama);
-}
-var selectAngleAxisWithScaleAndViewport = createSelector([
-	selectAngleAxisForRadar,
-	selectPolarAxisScaleForRadar,
-	selectPolarViewBox
-], (axisOptions, scale, polarViewBox) => {
-	if (polarViewBox == null) return;
-	return {
-		scale,
-		type: axisOptions.type,
-		dataKey: axisOptions.dataKey,
-		cx: polarViewBox.cx,
-		cy: polarViewBox.cy
-	};
-});
-function pickDataKey(_state, _radiusAxisId, _angleAxisId, _isPanorama, radarDataKey) {
-	return radarDataKey;
-}
-var selectBandSizeOfAxis = createSelector([
-	selectChartLayout,
-	selectRadiusAxisForBandSize,
-	selectRadiusAxisTicks,
-	selectAngleAxisForBandSize,
-	selectAngleAxisTicks
-], (layout, radiusAxis, radiusAxisTicks, angleAxis, angleAxisTicks) => {
-	if (isCategoricalAxis(layout, "radiusAxis")) return getBandSizeOfAxis(radiusAxis, radiusAxisTicks, false);
-	return getBandSizeOfAxis(angleAxis, angleAxisTicks, false);
-});
-var selectSynchronisedRadarDataKey = createSelector([selectUnfilteredPolarItems, pickDataKey], (graphicalItems, radarDataKey) => {
-	if (graphicalItems.some((pgis) => pgis.type === "radar" && radarDataKey === pgis.dataKey)) return radarDataKey;
-});
-function computeRadarPoints({ radiusAxis, angleAxis, displayedData, dataKey, bandSize }) {
-	const { cx, cy } = angleAxis;
-	let isRange = false;
-	const points = [];
-	const angleBandSize = angleAxis.type !== "number" ? bandSize ?? 0 : 0;
-	displayedData.forEach((entry, i) => {
-		const name = getValueByDataKey(entry, angleAxis.dataKey, i);
-		const value = getValueByDataKey(entry, dataKey);
-		const angle = (angleAxis.scale(name) ?? 0) + angleBandSize;
-		const pointValue = Array.isArray(value) ? last(value) : value;
-		const radius = isNullish(pointValue) ? 0 : radiusAxis.scale(pointValue) ?? 0;
-		if (Array.isArray(value) && value.length >= 2) isRange = true;
-		points.push({
-			...polarToCartesian(cx, cy, radius, angle),
-			name,
-			value,
-			cx,
-			cy,
-			radius,
-			angle,
-			payload: entry
-		});
-	});
-	const baseLinePoints = [];
-	if (isRange) points.forEach((point) => {
-		if (Array.isArray(point.value)) {
-			const baseValue = point.value[0];
-			const radius = isNullish(baseValue) ? 0 : radiusAxis.scale(baseValue) ?? 0;
-			baseLinePoints.push({
-				...point,
-				radius,
-				...polarToCartesian(cx, cy, radius, point.angle)
-			});
-		} else baseLinePoints.push(point);
-	});
-	return {
-		points,
-		isRange,
-		baseLinePoints
-	};
-}
-var selectRadarPoints = createSelector([
-	selectRadiusAxisForRadar,
-	selectAngleAxisWithScaleAndViewport,
-	selectChartDataAndAlwaysIgnoreIndexes,
-	selectSynchronisedRadarDataKey,
-	selectBandSizeOfAxis
-], (radiusAxis, angleAxis, { chartData, dataStartIndex, dataEndIndex }, dataKey, bandSize) => {
-	if (radiusAxis == null || angleAxis == null || chartData == null || bandSize == null || dataKey == null) return;
-	return computeRadarPoints({
-		radiusAxis,
-		angleAxis,
-		displayedData: chartData.slice(dataStartIndex, dataEndIndex + 1),
-		dataKey,
-		bandSize
-	});
-});
-//#endregion
-export { selectRadarPoints };