cx 21.12.4 → 22.1.2

package/dist/charts.js

@@ -1037,6 +1037,174 @@ debug("The Pie class is deprecated. Please use PieChart instead.");
 var Pie = PieChart;
 Pie.Slice = PieSlice;
 
+var PieLabel = /*#__PURE__*/ (function(_BoundedObject) {
+	_inheritsLoose(PieLabel, _BoundedObject);
+
+	function PieLabel() {
+		return _BoundedObject.apply(this, arguments) || this;
+	}
+
+	var _proto = PieLabel.prototype;
+
+	_proto.init = function init() {
+		this.lineStyle = parseStyle(this.lineStyle);
+
+		_BoundedObject.prototype.init.call(this);
+	};
+
+	_proto.declareData = function declareData() {
+		var _BoundedObject$protot;
+
+		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+			args[_key] = arguments[_key];
+		}
+
+		(_BoundedObject$protot = _BoundedObject.prototype.declareData).call.apply(
+			_BoundedObject$protot,
+			[this].concat(args, [
+				{
+					distance: undefined,
+					lineStyle: {
+						structured: true
+					},
+					lineStroke: undefined,
+					lineClass: {
+						structured: true
+					},
+					lineColorIndex: undefined
+				}
+			])
+		);
+	};
+
+	_proto.calculateBounds = function calculateBounds(context, instance) {
+		var data = instance.data;
+		var bounds = Rect.add(Rect.add(Rect.multiply(instance.parentRect, data.anchors), data.offset), data.margin);
+		instance.originalBounds = bounds;
+		instance.actualBounds = context.placePieLabel(bounds, data.distance);
+		return new Rect({
+			t: 0,
+			r: bounds.width(),
+			b: bounds.height(),
+			l: 0
+		});
+	};
+
+	_proto.prepare = function prepare(context, instance) {
+		_BoundedObject.prototype.prepare.call(this, context, instance);
+
+		if (!context.registerPieLabel)
+			throw new Error("PieLabel components are allowed only within PieLabelsContainer components.");
+		context.registerPieLabel(instance);
+	};
+
+	_proto.render = function render(context, instance, key) {
+		var originalBounds = instance.originalBounds,
+			actualBounds = instance.actualBounds,
+			data = instance.data;
+		return /*#__PURE__*/ jsxs(
+			"g",
+			{
+				className: data.classNames,
+				children: [
+					/*#__PURE__*/ jsx("line", {
+						className: this.CSS.element(
+							this.baseClass,
+							"line",
+							data.lineColorIndex != null && "color-" + data.lineColorIndex
+						),
+						x1: actualBounds.l < originalBounds.l ? actualBounds.r : actualBounds.l,
+						y1: (actualBounds.t + actualBounds.b) / 2,
+						x2: (originalBounds.l + originalBounds.r) / 2,
+						y2: (originalBounds.t + originalBounds.b) / 2,
+						stroke: data.lineStroke,
+						style: data.lineStyle
+					}),
+					/*#__PURE__*/ jsx("g", {
+						transform: "translate(" + instance.actualBounds.l + " " + instance.actualBounds.t + ")",
+						children: this.renderChildren(context, instance)
+					})
+				]
+			},
+			key
+		);
+	};
+
+	return PieLabel;
+})(BoundedObject);
+PieLabel.prototype.distance = 100;
+PieLabel.prototype.baseClass = "pielabel";
+PieLabel.prototype.styled = true;
+
+var PieLabelsContainer = /*#__PURE__*/ (function(_BoundedObject) {
+	_inheritsLoose(PieLabelsContainer, _BoundedObject);
+
+	function PieLabelsContainer() {
+		return _BoundedObject.apply(this, arguments) || this;
+	}
+
+	var _proto = PieLabelsContainer.prototype;
+
+	_proto.prepare = function prepare(context, instance) {
+		_BoundedObject.prototype.prepare.call(this, context, instance);
+
+		var bounds = instance.data.bounds;
+		var cx2 = bounds.l + bounds.r;
+		context.push("placePieLabel", function(labelBounds, distance) {
+			var clone = new Rect(labelBounds);
+			var w = clone.r - clone.l;
+
+			if (clone.l + clone.r > cx2) {
+				clone.r = Math.min(clone.r + distance, bounds.r);
+				clone.l = clone.r - w;
+			} else {
+				clone.l = Math.max(bounds.l, clone.l - distance);
+				clone.r = clone.l + w;
+			}
+
+			return clone;
+		});
+		instance.leftLabels = [];
+		instance.rightLabels = [];
+		context.push("registerPieLabel", function(label) {
+			if (label.actualBounds.l + label.actualBounds.r < cx2) instance.leftLabels.push(label);
+			else instance.rightLabels.push(label);
+		});
+	};
+
+	_proto.prepareCleanup = function prepareCleanup(context, instance) {
+		context.pop("placePieLabel");
+		context.pop("registerPieLabel");
+
+		_BoundedObject.prototype.prepareCleanup.call(this, context, instance);
+
+		this.distributeLabels(instance.leftLabels, instance);
+		this.distributeLabels(instance.rightLabels, instance);
+	};
+
+	_proto.distributeLabels = function distributeLabels(labels, instance) {
+		labels.sort(function(a, b) {
+			return a.actualBounds.t + a.actualBounds.b - (b.actualBounds.t + b.actualBounds.b);
+		});
+		var totalHeight = labels.reduce(function(h, l) {
+			return h + l.actualBounds.height();
+		}, 0);
+		var bounds = instance.data.bounds;
+		var avgHeight = Math.min(totalHeight, bounds.height()) / labels.length;
+		var at = bounds.t;
+
+		for (var i = 0; i < labels.length; i++) {
+			var ab = labels[i].actualBounds;
+			ab.t = Math.max(at, Math.min(ab.t, bounds.b - (labels.length - i) * avgHeight));
+			ab.b = ab.t + avgHeight;
+			at = ab.b;
+		}
+	};
+
+	return PieLabelsContainer;
+})(BoundedObject);
+PieLabelsContainer.prototype.anchors = "0 1 1 0";
+
 var ColumnBarBase = /*#__PURE__*/ (function(_PureContainer) {
 	_inheritsLoose(ColumnBarBase, _PureContainer);
 
@@ -5412,6 +5580,8 @@ export {
 	NumericAxis,
 	Pie,
 	PieChart,
+	PieLabel,
+	PieLabelsContainer,
 	PieSlice,
 	PointReducer,
 	Range,