cx 24.2.0 → 24.3.0

package/dist/charts.js

@@ -634,43 +634,98 @@ var PieCalculator = /*#__PURE__*/ (function () {
 	};
 	return PieCalculator;
 })();
-function createSvgArc(x, y, r0, r, startAngle, endAngle) {
-	if (startAngle > endAngle) {
-		var s = startAngle;
-		startAngle = endAngle;
-		endAngle = s;
+function createSvgArc(x, y, r0, r, startAngleRadian, endAngleRadian, br) {
+	if (r0 === void 0) {
+		r0 = 0;
 	}
-	var largeArc = endAngle - startAngle <= Math.PI ? 0 : 1;
-	if (endAngle - startAngle >= 2 * Math.PI - 0.0001) endAngle = startAngle + 2 * Math.PI - 0.0001;
-	var result = [];
-	var startX, startY;
-	if (r0 > 0) {
-		startX = x + Math.cos(endAngle) * r0;
-		startY = y - Math.sin(endAngle) * r0;
-		result.push("M", startX, startY);
-		result.push("A", r0, r0, 0, largeArc, 1, x + Math.cos(startAngle) * r0, y - Math.sin(startAngle) * r0);
+	if (br === void 0) {
+		br = 0;
+	}
+	if (startAngleRadian > endAngleRadian) {
+		var s = startAngleRadian;
+		startAngleRadian = endAngleRadian;
+		endAngleRadian = s;
+	}
+	var path = [];
+	// limit br size based on r and r0
+	if (br > (r - r0) / 2) br = (r - r0) / 2;
+	var largeArc = endAngleRadian - startAngleRadian > Math.PI ? 1 : 0;
+	if (br > 0) {
+		if (r0 > 0) {
+			var innerBr = br;
+			var innerSmallArcAngle = Math.asin(br / (r0 + br));
+			if (innerSmallArcAngle > (endAngleRadian - startAngleRadian) / 2) {
+				innerSmallArcAngle = (endAngleRadian - startAngleRadian) / 2;
+				var sin = Math.sin(innerSmallArcAngle);
+				// correct br according to newly calculated border radius angle
+				innerBr = (r0 * sin) / (1 - sin);
+			}
+			var innerHip = Math.cos(innerSmallArcAngle) * (r0 + innerBr);
+			var innerSmallArc1XFrom = x + Math.cos(endAngleRadian) * innerHip;
+			var innerSmallArc1YFrom = y - Math.sin(endAngleRadian) * innerHip;
+
+			// move from the first small inner arc
+			path.push(move(innerSmallArc1XFrom, innerSmallArc1YFrom));
+			var innerSmallArc1XTo = x + Math.cos(endAngleRadian - innerSmallArcAngle) * r0;
+			var innerSmallArc1YTo = y - Math.sin(endAngleRadian - innerSmallArcAngle) * r0;
+
+			// add first small inner arc
+			path.push(arc(innerBr, innerBr, 0, 0, 0, innerSmallArc1XTo, innerSmallArc1YTo));
+			var innerArcXTo = x + Math.cos(startAngleRadian + innerSmallArcAngle) * r0;
+			var innerArcYTo = y - Math.sin(startAngleRadian + innerSmallArcAngle) * r0;
+
+			// add large inner arc
+			path.push(arc(r0, r0, 0, largeArc, 1, innerArcXTo, innerArcYTo));
+			var innerSmallArc2XTo = x + Math.cos(startAngleRadian) * innerHip;
+			var innerSmallArc2YTo = y - Math.sin(startAngleRadian) * innerHip;
+			// add second small inner arc
+			path.push(arc(innerBr, innerBr, 0, 0, 0, innerSmallArc2XTo, innerSmallArc2YTo));
+		} else {
+			path.push(move(x, y));
+		}
+		var outerBr = br;
+		var outerSmallArcAngle = Math.asin(br / (r - br));
+		if (outerSmallArcAngle > (endAngleRadian - startAngleRadian) / 2) {
+			outerSmallArcAngle = (endAngleRadian - startAngleRadian) / 2;
+			var _sin = Math.sin(outerSmallArcAngle);
+			// correct br according to newly calculated border radius angle
+			outerBr = (r * _sin) / (1 + _sin);
+		}
+		var outerHip = Math.cos(outerSmallArcAngle) * (r - outerBr);
+		var outerSmallArc1XFrom = x + Math.cos(startAngleRadian) * outerHip;
+		var outerSmallArc1YFrom = y - Math.sin(startAngleRadian) * outerHip;
+		var outerSmallArc1XTo = x + Math.cos(startAngleRadian + outerSmallArcAngle) * r;
+		var outerSmallArc1YTo = y - Math.sin(startAngleRadian + outerSmallArcAngle) * r;
+		var outerLargeArcXTo = x + Math.cos(endAngleRadian - outerSmallArcAngle) * r;
+		var outerLargeArcYTo = y - Math.sin(endAngleRadian - outerSmallArcAngle) * r;
+		var outerSmallArc2XTo = x + Math.cos(endAngleRadian) * outerHip;
+		var outerSmallArc2YTo = y - Math.sin(endAngleRadian) * outerHip;
+		path.push(
+			line$1(outerSmallArc1XFrom, outerSmallArc1YFrom),
+			arc(outerBr, outerBr, 0, 0, 0, outerSmallArc1XTo, outerSmallArc1YTo),
+			arc(r, r, 0, largeArc, 0, outerLargeArcXTo, outerLargeArcYTo),
+			arc(outerBr, outerBr, 0, 0, 0, outerSmallArc2XTo, outerSmallArc2YTo),
+		);
 	} else {
-		startX = x;
-		startY = y;
-		result.push("M", startX, startY);
+		if (r0 > 0) {
+			var startX = x + Math.cos(endAngleRadian) * r0;
+			var startY = y - Math.sin(endAngleRadian) * r0;
+			path.push(move(startX, startY));
+			var innerArcToX = x + Math.cos(startAngleRadian) * r0;
+			var innerArcToY = y - Math.sin(startAngleRadian) * r0;
+			path.push(arc(r0, r0, 0, largeArc, 1, innerArcToX, innerArcToY));
+		} else {
+			path.push(move(x, y));
+		}
+		var lineToX = x + Math.cos(startAngleRadian) * r;
+		var lineToY = y - Math.sin(startAngleRadian) * r;
+		path.push(line$1(lineToX, lineToY));
+		var arcToX = x + Math.cos(endAngleRadian) * r;
+		var arcToY = y - Math.sin(endAngleRadian) * r;
+		path.push(arc(r, r, 0, largeArc, 0, arcToX, arcToY));
 	}
-	result.push(
-		"L",
-		x + Math.cos(startAngle) * r,
-		y - Math.sin(startAngle) * r,
-		"A",
-		r,
-		r,
-		0,
-		largeArc,
-		0,
-		x + Math.cos(endAngle) * r,
-		y - Math.sin(endAngle) * r,
-		"L",
-		startX,
-		startY,
-	);
-	return result.join(" ");
+	path.push(z());
+	return path.join(" ");
 }
 PieChart.prototype.anchors = "0 1 1 0";
 PieChart.prototype.angle = 360;
@@ -683,6 +738,7 @@ var PieSlice = /*#__PURE__*/ (function (_Container) {
 	var _proto3 = PieSlice.prototype;
 	_proto3.init = function init() {
 		this.selection = Selection.create(this.selection);
+		if (this.borderRadius) this.br = this.borderRadius;
 		_Container.prototype.init.call(this);
 	};
 	_proto3.declareData = function declareData() {
@@ -708,6 +764,7 @@ var PieSlice = /*#__PURE__*/ (function (_Container) {
 					stack: undefined,
 					legend: undefined,
 					hoverId: undefined,
+					br: undefined,
 				},
 			]),
 		);
@@ -829,6 +886,7 @@ var PieSlice = /*#__PURE__*/ (function (_Container) {
 				data.r * segment.radiusMultiplier,
 				segment.startAngle,
 				segment.endAngle,
+				data.br,
 			);
 			return /*#__PURE__*/ jsxs(
 				"g",
@@ -869,6 +927,18 @@ var PieSlice = /*#__PURE__*/ (function (_Container) {
 	};
 	return PieSlice;
 })(Container);
+function move(x, y) {
+	return "M " + x + " " + y;
+}
+function line$1(x, y) {
+	return "L " + x + " " + y;
+}
+function z() {
+	return "Z";
+}
+function arc(rx, ry, xRotation, largeArc, sweep, x, y) {
+	return "A " + rx + " " + ry + " " + xRotation + " " + largeArc + " " + sweep + " " + x + " " + y;
+}
 PieSlice.prototype.offset = 0;
 PieSlice.prototype.r0 = 0;
 PieSlice.prototype.r = 50;

package/dist/data.js

@@ -111,21 +111,6 @@ function isBinding(value) {
 	return value instanceof Binding;
 }
 
-function _construct(t, e, r) {
-	if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
-	var o = [null];
-	o.push.apply(o, e);
-	var p = new (t.bind.apply(t, o))();
-	return r && _setPrototypeOf(p, r.prototype), p;
-}
-function _isNativeReflectConstruct() {
-	try {
-		var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-	} catch (t) {}
-	return (_isNativeReflectConstruct = function () {
-		return !!t;
-	})();
-}
 function _extends() {
 	_extends = Object.assign
 		? Object.assign.bind()
@@ -156,6 +141,32 @@ function _setPrototypeOf(o, p) {
 			};
 	return _setPrototypeOf(o, p);
 }
+function _isNativeReflectConstruct() {
+	if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+	if (Reflect.construct.sham) return false;
+	if (typeof Proxy === "function") return true;
+	try {
+		Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+function _construct(Parent, args, Class) {
+	if (_isNativeReflectConstruct()) {
+		_construct = Reflect.construct.bind();
+	} else {
+		_construct = function _construct(Parent, args, Class) {
+			var a = [null];
+			a.push.apply(a, args);
+			var Constructor = Function.bind.apply(Parent, a);
+			var instance = new Constructor();
+			if (Class) _setPrototypeOf(instance, Class.prototype);
+			return instance;
+		};
+	}
+	return _construct.apply(null, arguments);
+}
 function _assertThisInitialized(self) {
 	if (self === void 0) {
 		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");