@pie-lib/charting 7.0.4-next.29 → 7.0.4-next.30

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, n) => {
+	let r = {};
+	for (var i in e) t(r, i, {
+		get: e[i],
+		enumerable: !0
+	});
+	return n || t(r, Symbol.toStringTag, { value: "Module" }), r;
+}, c = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, l = (e, t, n) => (c(e, t, "default"), n && c(n, t, "default")), u = (n, r, a) => (a = n == null ? {} : e(i(n)), c(r || !n || !n.__esModule ? t(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n)), d = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, t) => (typeof require < "u" ? require : e)[t] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { o as __commonJSMin, s as __exportAll, l as __reExport, d as __require, u as __toESM };

package/dist/actions-button.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @synced-from pie-lib/packages/charting/src/actions-button.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare class ActionsButton extends React.Component {
+    constructor(props: any);
+    componentWillUnmount(): void;
+    static propTypes: {
+        addCategory: PropTypes.Validator<(...args: any[]) => any>;
+        deleteCategory: PropTypes.Validator<(...args: any[]) => any>;
+        language: PropTypes.Requireable<string>;
+        categories: PropTypes.Requireable<any[]>;
+    };
+    handleActionsClick: any;
+    handleActionsClose: any;
+    handleAddCategory: any;
+    handleDeleteCategory: any;
+    render(): React.JSX.Element;
+}
+export default ActionsButton;

package/dist/actions-button.js

@@ -0,0 +1,84 @@
+import e from "react";
+import t from "prop-types";
+import { styled as n } from "@mui/material/styles";
+import { color as r } from "@pie-lib/render-ui";
+import { jsx as i, jsxs as a } from "react/jsx-runtime";
+import o from "@mui/material/Button";
+import s from "@mui/material/Popover";
+import c from "@mui/material/Paper";
+import l from "@pie-lib/translator";
+//#region src/actions-button.tsx
+var { translator: u } = l, d = n("div")(() => ({ alignSelf: "flex-end" })), f = n("div")(({ theme: e }) => ({
+	cursor: "pointer",
+	fontSize: e.typography.fontSize,
+	color: r.tertiary(),
+	padding: e.spacing(1)
+})), p = n(c)(({ theme: e }) => ({
+	padding: e.spacing(1),
+	display: "flex",
+	flexDirection: "column",
+	gap: e.spacing(1),
+	"& button": {
+		textTransform: "none",
+		fontSize: e.typography.fontSize,
+		color: r.text(),
+		justifyContent: "flex-start"
+	}
+})), m = class extends e.Component {
+	constructor(e) {
+		super(e), this.state = { actionsAnchorEl: null };
+	}
+	componentWillUnmount() {
+		this.setState({ actionsAnchorEl: null });
+	}
+	static propTypes = {
+		addCategory: t.func.isRequired,
+		deleteCategory: t.func.isRequired,
+		language: t.string,
+		categories: t.array
+	};
+	handleActionsClick = (e) => {
+		this.setState({ actionsAnchorEl: e.currentTarget });
+	};
+	handleActionsClose = () => {
+		this.setState({ actionsAnchorEl: null });
+	};
+	handleAddCategory = () => {
+		let { addCategory: e } = this.props;
+		e(), this.handleActionsClose();
+	};
+	handleDeleteCategory = (e) => {
+		let { deleteCategory: t } = this.props;
+		t(e), this.handleActionsClose();
+	};
+	render() {
+		let { categories: e, language: t } = this.props, { actionsAnchorEl: n } = this.state;
+		return /* @__PURE__ */ a(d, { children: [/* @__PURE__ */ i(f, {
+			role: "button",
+			tabIndex: 0,
+			onClick: this.handleActionsClick,
+			children: "Actions"
+		}), /* @__PURE__ */ i(s, {
+			open: !!n,
+			anchorEl: n,
+			onClose: this.handleActionsClose,
+			anchorOrigin: {
+				vertical: "bottom",
+				horizontal: "left"
+			},
+			transformOrigin: {
+				vertical: "top",
+				horizontal: "left"
+			},
+			children: /* @__PURE__ */ a(p, { children: [/* @__PURE__ */ a(o, {
+				onClick: () => this.handleAddCategory(),
+				children: ["+ ", u.t("charting.add", { lng: t })]
+			}), e.length > 0 && e.map((e, n) => e.deletable && !e.correctness && /* @__PURE__ */ i(o, {
+				onClick: () => this.handleDeleteCategory(n),
+				children: `${u.t("charting.delete", { lng: t })} <${e.label || u.t("charting.newLabel", { lng: t })}>`
+			}, n))] })
+		}, `actions-popover-${Math.random()}`)] });
+	}
+};
+//#endregion
+export { m as default };

package/dist/autosize-input.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface AutosizeInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'className' | 'style'> {
+    className?: string;
+    inputClassName?: string;
+    inputRef?: (node: HTMLInputElement | null) => void;
+    inputStyle?: React.CSSProperties;
+    minWidth?: number | string;
+    style?: React.CSSProperties;
+}
+export declare const AutosizeInput: React.ForwardRefExoticComponent<AutosizeInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/autosize-input.js

@@ -0,0 +1,66 @@
+import e, { useCallback as t, useLayoutEffect as n, useRef as r, useState as i } from "react";
+import { jsx as a, jsxs as o } from "react/jsx-runtime";
+//#region src/autosize-input.tsx
+var s = (e) => {
+	let t = Number.parseFloat(e);
+	return Number.isFinite(t) ? t : 0;
+}, c = (e, t) => {
+	let n = e ?? t;
+	return typeof n == "number" ? n : typeof n == "string" && n.endsWith("px") ? s(n) : 1;
+}, l = e.forwardRef(({ className: e, inputClassName: l, inputRef: u, inputStyle: d, minWidth: f, placeholder: p, style: m, value: h, defaultValue: g, ..._ }, v) => {
+	let y = r(null), b = r(u), x = r(v), S = r(null), [C, w] = i(() => c(f, d?.minWidth));
+	b.current = u, x.current = v;
+	let T = t((e) => {
+		y.current = e, b.current?.(e);
+		let t = x.current;
+		typeof t == "function" ? t(e) : t && (t.current = e);
+	}, []);
+	return n(() => {
+		let e = y.current, t = S.current;
+		if (!e || !t) return;
+		let n = window.getComputedStyle(e);
+		t.style.font = n.font, t.style.letterSpacing = n.letterSpacing, t.style.textTransform = n.textTransform, t.textContent = String(h ?? g ?? p ?? "") || " ";
+		let r = s(n.paddingLeft) + s(n.paddingRight) + s(n.borderLeftWidth) + s(n.borderRightWidth), i = Math.ceil(t.getBoundingClientRect().width + 2), a = n.boxSizing === "border-box" ? i + r : i;
+		w(Math.max(c(f, d?.minWidth), a));
+	}, [
+		g,
+		l,
+		d,
+		f,
+		p,
+		h
+	]), /* @__PURE__ */ o("span", {
+		className: e,
+		style: {
+			display: "inline-block",
+			...m
+		},
+		children: [/* @__PURE__ */ a("input", {
+			..._,
+			ref: T,
+			className: l,
+			placeholder: p,
+			style: {
+				width: C,
+				...d
+			},
+			value: h,
+			defaultValue: g
+		}), /* @__PURE__ */ a("span", {
+			ref: S,
+			"aria-hidden": "true",
+			style: {
+				height: 0,
+				left: 0,
+				overflow: "hidden",
+				position: "absolute",
+				top: 0,
+				visibility: "hidden",
+				whiteSpace: "pre"
+			}
+		})]
+	});
+});
+l.displayName = "AutosizeInput";
+//#endregion
+export { l as AutosizeInput };

package/dist/axes.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @synced-from pie-lib/packages/charting/src/axes.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare class TickComponent extends React.Component {
+    static propTypes: {
+        defineChart: PropTypes.Requireable<boolean>;
+        error: PropTypes.Requireable<any>;
+    };
+    constructor(props: any);
+    componentDidUpdate(prevProps: any): void;
+    handleAlertDialog: (open: any, callback: any) => void;
+    changeCategory: any;
+    changeInteractive: any;
+    changeEditable: any;
+    splitText: any;
+    render(): React.JSX.Element | null;
+}
+export declare class RawChartAxes extends React.Component {
+    static propTypes: {
+        bottomScale: PropTypes.Requireable<(...args: any[]) => any>;
+        categories: PropTypes.Requireable<any[]>;
+        defineChart: PropTypes.Requireable<boolean>;
+        error: PropTypes.Requireable<any>;
+        graphProps: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            scale: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            snap: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                x: PropTypes.Validator<(...args: any[]) => any>;
+                y: PropTypes.Validator<(...args: any[]) => any>;
+            }>>>;
+            domain: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            range: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                min: PropTypes.Validator<number>;
+                max: PropTypes.Validator<number>;
+                step: PropTypes.Requireable<number>;
+            }>>>;
+            size: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                width: PropTypes.Validator<number>;
+                height: PropTypes.Validator<number>;
+            }>>>;
+        }>>>;
+        xBand: PropTypes.Requireable<(...args: any[]) => any>;
+        leftAxis: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onChangeCategory: PropTypes.Requireable<(...args: any[]) => any>;
+        top: PropTypes.Requireable<number>;
+        theme: PropTypes.Requireable<object>;
+        chartingOptions: PropTypes.Requireable<object>;
+        changeInteractiveEnabled: PropTypes.Requireable<boolean>;
+        changeEditableEnabled: PropTypes.Requireable<boolean>;
+        autoFocus: PropTypes.Requireable<boolean>;
+        onAutoFocusUsed: PropTypes.Requireable<(...args: any[]) => any>;
+        showCorrectness: PropTypes.Requireable<boolean>;
+        hiddenLabelRef: PropTypes.Requireable<NonNullable<((...args: any[]) => any) | PropTypes.InferProps<{
+            current: PropTypes.Requireable<Element>;
+        }> | null | undefined>>;
+    };
+    state: {
+        height: number;
+        width: number;
+    };
+    measureHiddenLabel: any;
+    _onDocMutation: any;
+    observeHiddenLabel: any;
+    setHiddenLabelRef: any;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: any): void;
+    render(): React.JSX.Element;
+}
+export default RawChartAxes;

package/dist/axes.js

@@ -0,0 +1,376 @@
+import e from "./node_modules/.bun/@visx_axis@3.12.0_f4eacebf2041cd4f/node_modules/@visx/axis/esm/axis/AxisLeft.js";
+import t from "./node_modules/.bun/@visx_axis@3.12.0_f4eacebf2041cd4f/node_modules/@visx/axis/esm/axis/AxisBottom.js";
+import { TickCorrectnessIndicator as n } from "./common/correctness-indicators.js";
+import { bandKey as r, getRotateAngle as i, getTickValues as a } from "./utils.js";
+import o from "./mark-label.js";
+import s from "react";
+import c from "prop-types";
+import { styled as l } from "@mui/material/styles";
+import { types as u } from "@pie-lib/plot";
+import { AlertDialog as d } from "@pie-lib/config-ui";
+import { color as f } from "@pie-lib/render-ui";
+import { jsx as p, jsxs as m } from "react/jsx-runtime";
+import h from "@mui/material/Checkbox";
+import { renderMath as g } from "@pie-element/shared-math-rendering-mathjax";
+//#region src/axes.tsx
+var _ = /* @__PURE__ */ new Set(), v = null;
+function y(e) {
+	_.add(e), !v && typeof document < "u" && (v = new MutationObserver(() => {
+		_.forEach((e) => e());
+	}), v.observe(document.body, {
+		childList: !0,
+		subtree: !0
+	}));
+}
+function b(e) {
+	_.delete(e), _.size === 0 && v && (v.disconnect(), v = null);
+}
+var x = l("text")(({ theme: e }) => ({
+	fontSize: e.typography.fontSize - 2,
+	fill: e.palette.error.main
+})), S = l(h)(() => ({ color: `${f.tertiary()} !important` })), C = l("g")(({ theme: e }) => ({
+	"& .vx-axis-line": {
+		stroke: f.visualElementsColors.AXIS_LINE_COLOR,
+		strokeWidth: 2
+	},
+	"& .vx-axis-tick": {
+		fill: f.visualElementsColors.AXIS_TICK_COLOR,
+		"& line": {
+			stroke: f.visualElementsColors.AXIS_TICK_COLOR,
+			strokeWidth: 2
+		},
+		fontFamily: e.typography.body1?.fontFamily,
+		fontSize: e.typography.fontSize,
+		textAnchor: "middle"
+	}
+})), w = (e) => ({
+	borderRadius: e.spacing(2),
+	color: f.defaults.WHITE,
+	fontSize: "16px",
+	width: "16px",
+	height: "16px",
+	padding: "2px",
+	border: `1px solid ${f.defaults.WHITE}`,
+	boxSizing: "unset"
+}), T = { backgroundColor: f.incorrectWithIcon() }, E = { backgroundColor: f.correct() }, D = class extends s.Component {
+	static propTypes = {
+		defineChart: c.bool,
+		error: c.any
+	};
+	constructor(e) {
+		super(e), this.state = { dialog: { open: !1 } };
+	}
+	componentDidUpdate(e) {
+		this.props.autoFocus && !e.autoFocus && this.props.onAutoFocusUsed();
+	}
+	handleAlertDialog = (e, t) => this.setState({ dialog: { open: e } }, t);
+	changeCategory = (e, t) => {
+		let { categories: n, onChangeCategory: r } = this.props, i = n[e];
+		r(e, {
+			...i,
+			label: t
+		});
+	};
+	changeInteractive = (e, t) => {
+		let { categories: n, onChangeCategory: r } = this.props, i = n[e];
+		t ? r(e, {
+			...i,
+			interactive: !i.interactive
+		}) : this.setState({ dialog: {
+			open: !0,
+			title: "Warning",
+			text: "This will remove the correct answer value that has been defined for this category.",
+			onConfirm: () => this.handleAlertDialog(!1, r(e, {
+				...i,
+				interactive: !i.interactive
+			})),
+			onClose: () => this.handleAlertDialog(!1)
+		} });
+	};
+	changeEditable = (e, t) => {
+		let { categories: n, onChangeCategory: r } = this.props, i = n[e];
+		t ? r(e, {
+			...i,
+			editable: !i.editable || !1
+		}) : this.setState({ dialog: {
+			open: !0,
+			title: "Warning",
+			text: "This will remove the correct answer category name that has been defined for this category.",
+			onConfirm: () => this.handleAlertDialog(!1, r(e, {
+				...i,
+				editable: !i.editable || !1
+			})),
+			onClose: () => this.handleAlertDialog(!1)
+		} });
+	};
+	splitText = (e, t) => {
+		let n = [];
+		for (; (e || "").length > 0;) {
+			let r;
+			e.length > t ? (r = e.lastIndexOf(" ", t), r === -1 && (r = t)) : r = e.length, n.push(e.substring(0, r)), e = e.substring(r).trim();
+		}
+		return n;
+	};
+	render() {
+		let { categories: e, xBand: t, bandWidth: i, barWidth: a, rotate: s, top: c, graphProps: l, defineChart: u, chartingOptions: f, x: h, y: g, formattedValue: _, changeInteractiveEnabled: v, changeEditableEnabled: y, error: b, autoFocus: C, hiddenLabelRef: D, showCorrectness: O } = this.props;
+		if (!_) return null;
+		let k = {
+			correctnessIcon: w,
+			incorrectIcon: T,
+			correctIcon: E
+		}, { dialog: A } = this.state, { changeEditable: j, changeInteractive: M } = f || {}, N = parseInt(_.split("-")[0], 10), P = e[N], { editable: F, interactive: I, label: L, correctness: R } = P || {}, z = t(r({ label: L }, N)), B = (e || []).reduce((e, t) => (e && e.label ? e.label.length : 0) > (t && t.label ? t.label.length : 0) ? e : t, { label: "" }), V = b ? [...new Set(Object.values(b))].join(" ") : "";
+		return /* @__PURE__ */ m("g", { children: [
+			/* @__PURE__ */ m("foreignObject", {
+				x: i ? z : h - a / 2,
+				y: 18,
+				width: a,
+				height: 4,
+				style: {
+					pointerEvents: "none",
+					overflow: "visible"
+				},
+				children: [N === 0 && /* @__PURE__ */ p(o, {
+					isHiddenLabel: !0,
+					inputRef: D,
+					disabled: !0,
+					mark: B,
+					graphProps: l,
+					barWidth: a
+				}), /* @__PURE__ */ p(o, {
+					autoFocus: u && C,
+					inputRef: (e) => this.input = e,
+					disabled: !u && !F,
+					mark: P,
+					graphProps: l,
+					onChange: (e) => this.changeCategory(N, e),
+					barWidth: a,
+					rotate: s,
+					correctness: R,
+					error: b && b[N],
+					limitCharacters: !0,
+					correctnessIndicator: O && R && /* @__PURE__ */ p(n, {
+						correctness: R,
+						interactive: I,
+						classes: k
+					})
+				})]
+			}),
+			b && N === 0 && /* @__PURE__ */ p(x, {
+				y: g + 23,
+				height: 6,
+				textAnchor: "start",
+				children: V
+			}),
+			u && N === 0 && /* @__PURE__ */ m("svg", {
+				x: -55,
+				style: { overflow: "visible" },
+				children: [v && /* @__PURE__ */ p("text", {
+					y: g + 90 + c,
+					width: a,
+					height: 4,
+					style: {
+						position: "absolute",
+						pointerEvents: "none",
+						wordBreak: "break-word",
+						maxWidth: a,
+						display: "inline-block"
+					},
+					children: this.splitText(M?.authoringLabel, 20).map((e, t) => /* @__PURE__ */ p("tspan", {
+						x: "0",
+						dy: `${t > 0 ? "1.2em" : ".6em"}`,
+						children: e
+					}, t))
+				}), y && /* @__PURE__ */ p("text", {
+					y: g + 145 + c,
+					width: a,
+					height: 4,
+					style: {
+						position: "absolute",
+						pointerEvents: "none",
+						wordBreak: "break-word",
+						maxWidth: a,
+						display: "inline-block"
+					},
+					children: this.splitText(j?.authoringLabel, 20).map((e, t) => /* @__PURE__ */ p("tspan", {
+						x: "0",
+						dy: `${t > 0 ? "1.2em" : ".6em"}`,
+						children: e
+					}, t))
+				})]
+			}),
+			u && v && /* @__PURE__ */ p("foreignObject", {
+				x: h - 24,
+				y: g + 80 + c,
+				width: a,
+				height: 4,
+				style: {
+					pointerEvents: "visible",
+					overflow: "visible"
+				},
+				children: /* @__PURE__ */ p(S, {
+					style: { position: "fixed" },
+					checked: I,
+					onChange: (e) => this.changeInteractive(N, e.target.checked)
+				})
+			}),
+			u && y && /* @__PURE__ */ p("foreignObject", {
+				x: h - 24,
+				y: g + 130 + c,
+				width: a,
+				height: 4,
+				style: {
+					pointerEvents: "visible",
+					overflow: "visible"
+				},
+				children: /* @__PURE__ */ p(S, {
+					style: { position: "fixed" },
+					checked: F,
+					onChange: (e) => this.changeEditable(N, e.target.checked)
+				})
+			}),
+			/* @__PURE__ */ p("foreignObject", {
+				x: h - 24,
+				y: g + 100 + c,
+				width: a,
+				height: 4,
+				style: {
+					pointerEvents: "visible",
+					overflow: "visible"
+				},
+				children: /* @__PURE__ */ p(d, {
+					open: A.open,
+					title: A.title,
+					text: A.text,
+					onClose: A.onClose,
+					onConfirm: A.onConfirm
+				})
+			})
+		] });
+	}
+};
+D.propTypes = {
+	categories: c.array,
+	xBand: c.func,
+	bandWidth: c.number,
+	barWidth: c.number,
+	rotate: c.number,
+	top: c.number,
+	x: c.number,
+	y: c.number,
+	graphProps: c.object,
+	formattedValue: c.string,
+	onChangeCategory: c.func,
+	onChange: c.func,
+	error: c.object,
+	defineChart: c.bool,
+	chartingOptions: c.object,
+	changeInteractiveEnabled: c.bool,
+	changeEditableEnabled: c.bool,
+	autoFocus: c.bool,
+	onAutoFocusUsed: c.func,
+	showCorrectness: c.bool,
+	hiddenLabelRef: c.oneOfType([c.func, c.shape({ current: c.instanceOf(Element) })])
+};
+var O = class extends s.Component {
+	static propTypes = {
+		bottomScale: c.func,
+		categories: c.array,
+		defineChart: c.bool,
+		error: c.any,
+		graphProps: u.GraphPropsType.isRequired,
+		xBand: c.func,
+		leftAxis: c.bool,
+		onChange: c.func,
+		onChangeCategory: c.func,
+		top: c.number,
+		theme: c.object,
+		chartingOptions: c.object,
+		changeInteractiveEnabled: c.bool,
+		changeEditableEnabled: c.bool,
+		autoFocus: c.bool,
+		onAutoFocusUsed: c.func,
+		showCorrectness: c.bool,
+		hiddenLabelRef: c.oneOfType([c.func, c.shape({ current: c.instanceOf(Element) })])
+	};
+	state = {
+		height: 0,
+		width: 0
+	};
+	measureHiddenLabel = () => {
+		if (!this.hiddenLabelRef) return;
+		let e = this.hiddenLabelRef.querySelector("mjx-container"), t = this.hiddenLabelRef.querySelector("input"), n = (e || t || this.hiddenLabelRef).getBoundingClientRect(), r = Math.floor(n.height), i = Math.floor(n.width);
+		(r !== this.state.height || i !== this.state.width) && this.setState({
+			height: r,
+			width: i
+		});
+	};
+	_onDocMutation = () => {
+		this.hiddenLabelRef && this.hiddenLabelRef.querySelector("mjx-container") && this.measureHiddenLabel();
+	};
+	observeHiddenLabel = (e) => {
+		if (!e) return;
+		let t = e.querySelector("[data-latex], [data-raw]");
+		t && g(e), (e.querySelector("mjx-container") || !t) && this.measureHiddenLabel(), y(this._onDocMutation);
+	};
+	setHiddenLabelRef = (e) => {
+		e && e !== this.hiddenLabelRef && (this.hiddenLabelRef = e, this.observeHiddenLabel(e));
+	};
+	componentDidMount() {
+		this.hiddenLabelRef && this.observeHiddenLabel(this.hiddenLabelRef);
+	}
+	componentWillUnmount() {
+		b(this._onDocMutation), this._updateTimer && clearTimeout(this._updateTimer);
+	}
+	componentDidUpdate(e) {
+		e.categories !== this.props.categories && (this._updateTimer && clearTimeout(this._updateTimer), this._updateTimer = setTimeout(() => this.measureHiddenLabel(), 50));
+	}
+	render() {
+		let { graphProps: n, xBand: r, leftAxis: o, onChange: s, onChangeCategory: c, categories: l = [], top: u, defineChart: d, chartingOptions: f, changeInteractiveEnabled: h, changeEditableEnabled: g, theme: _, autoFocus: v, onAutoFocusUsed: y, error: b, showCorrectness: x } = this.props, { scale: S = {}, range: w = {}, domain: T = {}, size: E = {} } = n || {}, { height: O, width: k } = this.state, A = r && typeof r.rangeRound == "function" && r.rangeRound([0, E.width]), j = r && typeof r.bandwidth == "function" && r.bandwidth(), M = j || S.x && S.x(T.max) / l.length, N = a({
+			...w,
+			step: w.labelStep
+		}), P = i(_ && _.typography ? _.typography.fontSize : 14, O), F = k > M ? 25 : 0;
+		return /* @__PURE__ */ m(C, { children: [o && /* @__PURE__ */ p(e, {
+			scale: S.y,
+			tickLength: 10,
+			tickFormat: (e) => e,
+			tickValues: N,
+			tickLabelProps: (e) => ({
+				dy: 4,
+				dx: -10 - (e.toLocaleString().length || 1) * 5
+			})
+		}), /* @__PURE__ */ p(t, {
+			scale: A,
+			labelProps: { y: 60 + u },
+			top: S.y && S.y(w.min),
+			textLabelProps: () => ({ textAnchor: "middle" }),
+			tickFormat: (e) => e,
+			tickComponent: (e) => /* @__PURE__ */ p(D, {
+				hiddenLabelRef: this.setHiddenLabelRef,
+				categories: l,
+				xBand: r,
+				bandWidth: j,
+				barWidth: M,
+				rotate: P || F,
+				top: u,
+				defineChart: d,
+				chartingOptions: f,
+				autoFocus: v,
+				onAutoFocusUsed: y,
+				error: b,
+				onChangeCategory: c,
+				changeInteractiveEnabled: h,
+				changeEditableEnabled: g,
+				onChange: s,
+				graphProps: n,
+				x: e.x,
+				y: e.y,
+				formattedValue: e.formattedValue,
+				showCorrectness: x
+			}),
+			autoFocus: v,
+			onAutoFocusUsed: y
+		})] });
+	}
+};
+//#endregion
+export { O as default };