cx 24.4.8 → 24.4.9

package/dist/charts.css

@@ -259,6 +259,11 @@
   stroke-width: 1px;
 }
 
+.cxe-swimlane-lane {
+  fill: #f1f1f1;
+  stroke: none;
+}
+
 .cxs-color-0 {
   fill: #fbb4af;
   stroke: #e2a29e;

package/dist/charts.js

@@ -2803,6 +2803,173 @@ Swimlanes.prototype.vertical = false;
 Swimlanes.prototype.styled = true;
 BoundedObject.alias("swimlanes", Swimlanes);
 
+var Swimlane = /*#__PURE__*/ (function (_BoundedObject) {
+	function Swimlane() {
+		return _BoundedObject.apply(this, arguments) || this;
+	}
+	_inheritsLoose(Swimlane, _BoundedObject);
+	var _proto = Swimlane.prototype;
+	_proto.init = function init() {
+		this.laneStyle = parseStyle(this.laneStyle);
+		_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, [
+				{
+					size: undefined,
+					laneOffset: undefined,
+					laneStyle: {
+						structured: true,
+					},
+					vertical: undefined,
+					x: undefined,
+					y: undefined,
+				},
+			]),
+		);
+	};
+	_proto.explore = function explore(context, instance) {
+		var data = instance.data;
+		_BoundedObject.prototype.explore.call(this, context, instance);
+		instance.xAxis = context.axes[this.xAxis];
+		instance.yAxis = context.axes[this.yAxis];
+		if (data.vertical) {
+			instance.xAxis.acknowledge(data.x, data.size, data.laneOffset);
+		} else {
+			instance.yAxis.acknowledge(data.y, data.size, data.laneOffset);
+		}
+	};
+	_proto.prepare = function prepare(context, instance) {
+		_BoundedObject.prototype.prepare.call(this, context, instance);
+		instance.bounds = this.calculateRect(instance);
+		instance.cache("bounds", instance.bounds);
+		if (!instance.bounds.isEqual(instance.cached.bounds)) instance.markShouldUpdate(context);
+		context.push("parentRect", instance.bounds);
+	};
+	_proto.calculateRect = function calculateRect(instance) {
+		var data = instance.data;
+		var size = data.size,
+			laneOffset = data.laneOffset;
+		if (data.vertical) {
+			var x1 = instance.xAxis.map(data.x, laneOffset - size / 2);
+			var x2 = instance.xAxis.map(data.x, laneOffset + size / 2);
+			var bounds = new Rect({
+				l: Math.min(x1, x2),
+				r: Math.max(x1, x2),
+				t: data.bounds.t,
+				b: data.bounds.b,
+			});
+		} else {
+			var y1 = instance.yAxis.map(data.y, laneOffset - size / 2);
+			var y2 = instance.yAxis.map(data.y, laneOffset + size / 2);
+			var bounds = new Rect({
+				l: data.bounds.l,
+				r: data.bounds.r,
+				t: Math.min(y1, y2),
+				b: Math.max(y1, y2),
+			});
+		}
+		return bounds;
+	};
+	_proto.render = function render(context, instance, key) {
+		var data = instance.data,
+			xAxis = instance.xAxis,
+			yAxis = instance.yAxis,
+			bounds = instance.bounds;
+		var CSS = this.CSS,
+			baseClass = this.baseClass;
+		var axis = this.vertical ? xAxis : yAxis;
+		if (!axis) return null;
+		var min, max, valueFunction;
+		if (axis.scale) {
+			min = axis.scale.min;
+			max = axis.scale.max;
+			var clamp = function clamp(value) {
+				return [Math.max(min, Math.min(max, value)), 0];
+			};
+			valueFunction = function valueFunction(value, offset) {
+				return clamp(value + offset);
+			};
+		} else if (axis.valueList) {
+			min = 0;
+			max = axis.valueList.length;
+			valueFunction = function valueFunction(value, offset) {
+				return [axis.valueList[value], offset];
+			};
+		}
+		if (!(min < max)) return null;
+		var rectClass = CSS.element(baseClass, "lane");
+		if (this.vertical) {
+			var c1 = axis.map.apply(axis, valueFunction(data.x, -data.size / 2 + data.laneOffset));
+			var c2 = axis.map.apply(axis, valueFunction(data.x, +data.size / 2 + data.laneOffset));
+			return /*#__PURE__*/ jsxs(
+				"g",
+				{
+					className: data.classNames,
+					children: [
+						/*#__PURE__*/ jsx(
+							"rect",
+							{
+								x: bounds.l,
+								y: bounds.t,
+								height: bounds.b - bounds.t,
+								width: Math.abs(c1 - c2),
+								className: rectClass,
+								style: data.laneStyle,
+							},
+							key,
+						),
+						this.renderChildren(context, instance),
+						";",
+					],
+				},
+				key,
+			);
+		} else {
+			var _c = axis.map.apply(axis, valueFunction(data.y, -data.size / 2 + data.laneOffset));
+			var _c2 = axis.map.apply(axis, valueFunction(data.y, +data.size / 2 + data.laneOffset));
+			return /*#__PURE__*/ jsxs(
+				"g",
+				{
+					className: data.classNames,
+					children: [
+						/*#__PURE__*/ jsx(
+							"rect",
+							{
+								x: bounds.l,
+								y: bounds.t,
+								width: bounds.r - bounds.l,
+								height: Math.abs(_c - _c2),
+								className: rectClass,
+								style: data.laneStyle,
+							},
+							key,
+						),
+						this.renderChildren(context, instance),
+						";",
+					],
+				},
+				key,
+			);
+		}
+	};
+	return Swimlane;
+})(BoundedObject);
+Swimlane.prototype.xAxis = "x";
+Swimlane.prototype.yAxis = "y";
+Swimlane.prototype.anchors = "0 1 1 0";
+Swimlane.prototype.baseClass = "swimlane";
+Swimlane.prototype.size = 0.5;
+Swimlane.prototype.laneOffset = 0;
+Swimlane.prototype.vertical = false;
+BoundedObject.alias("swimlane", Swimlane);
+
 var RangeMarker = /*#__PURE__*/ (function (_BoundedObject) {
 	function RangeMarker() {
 		return _BoundedObject.apply(this, arguments) || this;
@@ -5226,6 +5393,7 @@ export {
 	RangeMarker,
 	ScatterGraph,
 	SnapPointFinder,
+	Swimlane,
 	Swimlanes,
 	TimeAxis,
 	ValueAtFinder,