@pie-lib/graphing 4.0.4-next.9 → 4.0.5-next.0

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 = (n, r, a) => (a = n == null ? {} : e(i(n)), c(r || !n || !n.__esModule ? t(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n)), u = /* @__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, u as __require, l as __toESM };

package/dist/axis/arrow.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/axis/arrow.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';
+export declare class Arrow extends React.Component {
+    render(): React.JSX.Element;
+}
+export default Arrow;

package/dist/axis/arrow.js

@@ -0,0 +1,34 @@
+import e from "react";
+import t from "prop-types";
+import { types as n } from "@pie-lib/plot";
+import { styled as r } from "@mui/material/styles";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/axis/arrow.tsx
+var a = r("path")(({ theme: e }) => ({ fill: `var(--arrow-color, ${e.palette.common.black})` })), o = class extends e.Component {
+	render() {
+		let { x: e, y: t, className: n, scale: r } = this.props, o = this.props.direction || "left", s = r.x(e), c = r.y(t), l = "", u = (e, t, n) => `translate(${e}, ${t}) rotate(${n})`;
+		return o === "left" && (l = u(s - 15, c, 0)), o === "right" && (l = u(s + 15, c, 180)), o === "up" && (l = u(s, c - 15, 90)), o === "down" && (l = u(s, c + 15, 270)), /* @__PURE__ */ i(a, {
+			d: "m 0,0 8,-5 0,10 -8,-5",
+			transform: l,
+			className: n
+		});
+	}
+};
+o.propTypes = {
+	y: t.number,
+	x: t.number,
+	direction: t.oneOf([
+		"left",
+		"right",
+		"up",
+		"down"
+	]),
+	className: t.string,
+	scale: n.ScaleType.isRequired
+}, o.defaultProps = {
+	y: 0,
+	x: 0,
+	direction: "left"
+};
+//#endregion
+export { o as default };

package/dist/axis/axes.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/axis/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 const AxisPropTypes: {
+    includeArrows: PropTypes.Requireable<object>;
+    graphProps: PropTypes.Requireable<object>;
+};
+export declare const sharedValues: (firstNegativeX: any, firstNegativeY: any, distanceFromOriginToFirstNegativeX: any, distanceFromOriginToFirstNegativeY: any, deltaAllowance: any, dy: any) => any[];
+export declare const firstNegativeValue: (interval: any) => any;
+export declare class RawXAxis extends React.Component {
+    static propTypes: {
+        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>;
+            }>>>;
+        }>>>;
+        includeArrows: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        includeArrows: {
+            left: boolean;
+            right: boolean;
+            up: boolean;
+            down: boolean;
+        };
+    };
+    render(): React.JSX.Element;
+}
+export declare class RawYAxis extends React.Component {
+    static propTypes: {
+        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>;
+            }>>>;
+        }>>>;
+        includeArrows: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        includeArrows: {
+            left: boolean;
+            right: boolean;
+            up: boolean;
+            down: boolean;
+        };
+    };
+    render(): React.JSX.Element;
+}
+export default class Axes extends React.Component {
+    static propTypes: {
+        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>;
+            }>>>;
+        }>>>;
+        includeArrows: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        includeArrows: {
+            left: boolean;
+            right: boolean;
+            up: boolean;
+            down: boolean;
+        };
+    };
+    xValues: any;
+    yValues: any;
+    render(): React.JSX.Element;
+}

package/dist/axis/axes.js

@@ -0,0 +1,214 @@
+import e from "../node_modules/.bun/@visx_axis@3.12.0_f4eacebf2041cd4f/node_modules/@visx/axis/esm/axis/Axis.js";
+import t from "./arrow.js";
+import { amountToIncreaseWidth as n, countWords as r, findLongestWord as i, getTickValues as a } from "../utils.js";
+import o from "react";
+import s from "prop-types";
+import { types as c } from "@pie-lib/plot";
+import { styled as l } from "@mui/material/styles";
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+import * as f from "@pie-lib/render-ui";
+import { Readable as p, color as m } from "@pie-lib/render-ui";
+//#region src/axis/axes.tsx
+function h(e) {
+	return typeof e == "function" || typeof e == "object" && !!e && typeof e.$$typeof == "symbol";
+}
+function g(e, t) {
+	return !e || h(e) ? e : h(e.default) ? e.default : t && h(e[t]) ? e[t] : t && h(e[t]?.default) ? e[t].default : e;
+}
+var _ = g(p, "Readable") || g(b.Readable, "Readable"), v = f, y = v.default, b = y && typeof y == "object" ? y : v, x = {
+	includeArrows: s.object,
+	graphProps: s.object
+}, S = { includeArrows: {
+	left: !0,
+	right: !0,
+	up: !0,
+	down: !0
+} }, C = l(t)(() => ({ fill: m.defaults.PRIMARY })), w = l("div")(({ theme: e, centered: t }) => ({
+	padding: 0,
+	margin: 0,
+	"* > *": {
+		margin: 0,
+		padding: 0
+	},
+	"& p": { margin: 0 },
+	fontSize: e.typography.fontSize,
+	...t && { textAlign: "center" }
+})), T = l("g")(() => ({
+	"& .visx-axis-line": {
+		stroke: m.defaults.PRIMARY,
+		strokeWidth: 3
+	},
+	"& .visx-axis-tick": {
+		fill: m.defaults.PRIMARY,
+		"& line": { stroke: m.defaults.PRIMARY }
+	}
+})), E = {
+	fontFamily: "Roboto",
+	fontSize: "14px",
+	cursor: "inherit"
+}, D = (e, t, n, r, i, a) => {
+	let o = [];
+	return e === t && n - i < r && r < n + i && n - i < a && a < n + i && o.push(e), o;
+}, O = (e) => (e || []).find((e) => e < 0), k = class extends o.Component {
+	static propTypes = {
+		...x,
+		graphProps: c.GraphPropsType.isRequired
+	};
+	static defaultProps = S;
+	render() {
+		let { includeArrows: t, graphProps: a, columnTicksValues: o, skipValues: s, distanceFromOriginToFirstNegativeY: c, dy: l } = this.props, { scale: f, domain: p, size: m, range: h } = a || {}, g = (e) => {
+			let t = s && s[0] === e ? c + 4 : l;
+			return {
+				...E,
+				textAnchor: "middle",
+				y: t,
+				dx: e === 0 ? -10 : 0,
+				dy: e === 0 ? -7 : 0
+			};
+		}, v = r(p.axisLabel), y = n(i(p.axisLabel)) + 2;
+		return /* @__PURE__ */ d(T, { children: [
+			/* @__PURE__ */ u(e, {
+				scale: f.x,
+				top: f.y(0),
+				left: 0,
+				label: p.label,
+				rangePadding: 8,
+				tickFormat: (e) => e,
+				tickLabelProps: g,
+				tickValues: o,
+				hideZero: !(p.labelStep || h.labelStep) && p.min <= 0
+			}),
+			t && t.left && /* @__PURE__ */ u(C, {
+				direction: "left",
+				x: p.min,
+				y: 0,
+				scale: f
+			}),
+			t && t.right && /* @__PURE__ */ u(C, {
+				direction: "right",
+				x: p.max,
+				y: 0,
+				scale: f
+			}),
+			p.axisLabel && /* @__PURE__ */ u("foreignObject", {
+				x: m.width + 17,
+				y: f.y(0) - 9,
+				width: y,
+				height: 20 * v,
+				children: /* @__PURE__ */ u(_, {
+					false: !0,
+					children: /* @__PURE__ */ u(w, { dangerouslySetInnerHTML: { __html: p.axisLabel } })
+				})
+			})
+		] });
+	}
+}, A = class extends o.Component {
+	static propTypes = {
+		...x,
+		graphProps: c.GraphPropsType.isRequired
+	};
+	static defaultProps = S;
+	render() {
+		let { includeArrows: t, graphProps: r, skipValues: i, rowTickValues: a } = this.props, { scale: o, range: s, size: c } = r || {}, l = s.axisLabel ? n(s.axisLabel.length) : 0;
+		return /* @__PURE__ */ d(T, { children: [
+			/* @__PURE__ */ u(e, {
+				orientation: "left",
+				scale: o.y,
+				top: 0,
+				height: c.height,
+				left: o.x(0),
+				label: s.label,
+				labelProps: { "data-pie-readable": !1 },
+				rangePadding: 8,
+				tickLength: 10,
+				tickFormat: (e) => i && i.indexOf(e) >= 0 ? "" : e,
+				tickLabelProps: (e) => {
+					let t = e.toLocaleString().replace(/[.-]/g, "").length || 1;
+					return {
+						...E,
+						dy: 4,
+						dx: -10 - t * 9,
+						"data-pie-readable": !1
+					};
+				},
+				hideZero: !0,
+				tickTextAnchor: "bottom",
+				tickValues: a
+			}),
+			t && t.down && /* @__PURE__ */ u(C, {
+				direction: "down",
+				x: 0,
+				y: s.min,
+				scale: o
+			}),
+			t && t.up && /* @__PURE__ */ u(C, {
+				direction: "up",
+				x: 0,
+				y: s.max,
+				scale: o
+			}),
+			s.axisLabel && /* @__PURE__ */ u("foreignObject", {
+				x: o.x(0) - l / 2,
+				y: -33,
+				width: l,
+				height: "20",
+				children: /* @__PURE__ */ u(_, {
+					false: !0,
+					children: /* @__PURE__ */ u(w, {
+						centered: !0,
+						dangerouslySetInnerHTML: { __html: s.axisLabel }
+					})
+				})
+			})
+		] });
+	}
+}, j = class extends o.Component {
+	static propTypes = {
+		...x,
+		graphProps: c.GraphPropsType.isRequired
+	};
+	static defaultProps = S;
+	xValues = () => {
+		let { graphProps: e } = this.props, { scale: t, domain: n } = e || {};
+		if (!n || !t) return;
+		let r = a({
+			...n,
+			step: n.labelStep
+		}), i = O(r);
+		return {
+			columnTicksValues: r,
+			firstNegativeX: i,
+			distanceFromOriginToFirstNegativeX: Math.abs(t.y(0) - t.y(i))
+		};
+	};
+	yValues = () => {
+		let { graphProps: e } = this.props, { scale: t, range: n } = e || {};
+		if (!n || !t) return;
+		let r = a({
+			...n,
+			step: n.labelStep
+		}), i = O(r);
+		return {
+			rowTickValues: r,
+			firstNegativeY: i,
+			distanceFromOriginToFirstNegativeY: Math.abs(t.x(0) - t.x(i))
+		};
+	};
+	render() {
+		let { graphProps: e } = this.props, { domain: t, range: n } = e || {}, { columnTicksValues: r, firstNegativeX: i, distanceFromOriginToFirstNegativeX: a } = this.xValues(), { rowTickValues: o, firstNegativeY: s, distanceFromOriginToFirstNegativeY: c } = this.yValues(), l = D(i, s, a, c, 6, 25);
+		return /* @__PURE__ */ d(T, { children: [n.min <= 0 ? /* @__PURE__ */ u(k, {
+			...this.props,
+			skipValues: l,
+			columnTicksValues: r,
+			distanceFromOriginToFirstNegativeY: c,
+			dy: 25
+		}) : null, t.min <= 0 ? /* @__PURE__ */ u(A, {
+			...this.props,
+			skipValues: l,
+			rowTickValues: o,
+			distanceFromOriginToFirstNegativeX: a
+		}) : null] });
+	}
+};
+//#endregion
+export { x as AxisPropTypes, j as default };

package/dist/axis/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/axis/index.js
+ * @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 Axes, { AxisPropTypes } from './axes.js';
+export { Axes, AxisPropTypes };

package/dist/bg.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/bg.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 default class Bg extends React.Component {
+    static propTypes: {
+        width: PropTypes.Validator<number>;
+        height: PropTypes.Validator<number>;
+        onClick: PropTypes.Validator<(...args: any[]) => 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>;
+            }>>>;
+        }>>>;
+    };
+    static defaultProps: {};
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: any): boolean;
+    getRectPadding: any;
+    /**
+     * Note: we use d3 click + pointer to give us domain values directly.
+     * Saves us having to calculate them ourselves from a MouseEvent.
+     */
+    onRectClick: any;
+    render(): React.JSX.Element;
+}

package/dist/bg.js

@@ -0,0 +1,44 @@
+import { getTickValues as e, thinnerShapesNeeded as t } from "./utils.js";
+import n from "react";
+import r from "prop-types";
+import { types as i, utils as a } from "@pie-lib/plot";
+import { jsx as o } from "react/jsx-runtime";
+import { pointer as s, select as c } from "d3-selection";
+//#region src/bg.tsx
+var l = class extends n.Component {
+	static propTypes = {
+		width: r.number.isRequired,
+		height: r.number.isRequired,
+		onClick: r.func.isRequired,
+		graphProps: i.GraphPropsType.isRequired
+	};
+	static defaultProps = {};
+	componentDidMount() {
+		let e = c(this.rect);
+		e.on("click", (t) => this.onRectClick(e, t));
+	}
+	shouldComponentUpdate(e) {
+		return !a.isDomainRangeEqual(this.props.graphProps, e.graphProps) || this.props.width !== e.width || this.props.height !== e.height;
+	}
+	getRectPadding = () => {
+		let { graphProps: e } = this.props;
+		return t(e) ? 6 : 10;
+	};
+	onRectClick = (t, n) => {
+		let { onClick: r, graphProps: i } = this.props, { scale: a } = i, o = this.getRectPadding(), c = s(n, t.node()), l = a.x.invert(c[0] - o), u = a.y.invert(c[1] - o), d = e(i.range), f = e(i.domain), p = (e, t) => e.length && e.reduce((e, n) => Math.abs(n - t) <= Math.abs(e - t) ? n : e), m = {};
+		f.indexOf(l) >= 0 && d.indexOf(u) >= 0 ? (m.x = l, m.y = u) : (m.x = p(f, l), m.y = p(d, u)), r(m);
+	};
+	render() {
+		let { width: e, height: t } = this.props, n = this.getRectPadding();
+		return /* @__PURE__ */ o("rect", {
+			ref: (e) => this.rect = e,
+			transform: `translate(-${n}, -${n})`,
+			fill: "red",
+			fillOpacity: "0.0",
+			width: e + n * 2,
+			height: t + n * 2
+		});
+	}
+};
+//#endregion
+export { l as default };

package/dist/container/actions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/container/actions.js
+ * @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.
+ */
+export declare const addMark: () => {
+    type: string;
+};
+export declare const changeMarks: (marks: any) => {
+    type: string;
+    marks: any;
+};

package/dist/container/actions.js

@@ -0,0 +1,7 @@
+//#region src/container/actions.ts
+var e = (e) => ({
+	type: "CHANGE_MARKS",
+	marks: e
+});
+//#endregion
+export { e as changeMarks };

package/dist/container/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/container/index.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 const GraphContainer: any;
+/**
+ * The graph component entry point with undo/redo
+ * Redux is an implementation detail, hide it in the react component.
+ */
+declare class Root extends React.Component {
+    static propTypes: {
+        onChangeMarks: PropTypes.Requireable<(...args: any[]) => any>;
+        marks: PropTypes.Requireable<any[]>;
+    };
+    constructor(props: any);
+    componentDidUpdate(prevProps: any): void;
+    onStoreChange: any;
+    render(): React.JSX.Element;
+}
+export default Root;

package/dist/container/index.js

@@ -0,0 +1,50 @@
+import e from "../node_modules/.bun/react-redux@6.0.1_926323a638b43722/node_modules/react-redux/es/components/Provider.js";
+import { applyMiddleware as t, createStore as n } from "../node_modules/.bun/redux@4.2.1/node_modules/redux/es/redux.js";
+import r from "../node_modules/.bun/react-redux@6.0.1_926323a638b43722/node_modules/react-redux/es/connect/connect.js";
+import "../node_modules/.bun/react-redux@6.0.1_926323a638b43722/node_modules/react-redux/es/index.js";
+import { M as i } from "../node_modules/.bun/redux-undo@1.1.0/node_modules/redux-undo/dist/redux-undo.js";
+import a from "./reducer.js";
+import { changeMarks as o } from "./actions.js";
+import s from "../graph-with-controls.js";
+import { lastActionMiddleware as c } from "./middleware.js";
+import l from "react";
+import u from "prop-types";
+import { isEqual as d } from "lodash-es";
+import { jsx as f } from "react/jsx-runtime";
+var p = r((e) => ({ marks: e.marks.present }), (e) => ({
+	onChangeMarks: (t) => e(o(t)),
+	onUndo: () => e(i.undo()),
+	onRedo: () => e(i.redo()),
+	onReset: () => e(o([]))
+}))(s), m = class extends l.Component {
+	static propTypes = {
+		onChangeMarks: u.func,
+		marks: u.array
+	};
+	constructor(e) {
+		super(e);
+		let r = a();
+		this.store = n(r, { marks: e.marks }, t(c)), this.store.subscribe(this.onStoreChange);
+	}
+	componentDidUpdate(e) {
+		let { marks: t } = this.props;
+		d(this.store.getState().marks.present, t) || d(e.marks, t) || t && t.find((e) => e.correctness) || this.store.dispatch(o(t));
+	}
+	onStoreChange = () => {
+		let { marks: e, onChangeMarks: t } = this.props, n = this.store.getState();
+		d(n.marks.present, e) || t(n.marks.present);
+	};
+	render() {
+		let { onChangeMarks: t, marks: n, ...r } = this.props, i = n && n.find((e) => e.correctness);
+		return i ? /* @__PURE__ */ f(s, {
+			...r,
+			marks: n,
+			disabled: i
+		}) : /* @__PURE__ */ f(e, {
+			store: this.store,
+			children: /* @__PURE__ */ f(p, { ...r })
+		});
+	}
+};
+//#endregion
+export { m as default };

package/dist/container/marks.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/container/marks.js
+ * @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.
+ */
+declare const marks: (state: never[] | undefined, action: any) => any;
+export default marks;

package/dist/container/marks.js

@@ -0,0 +1,11 @@
+//#region src/container/marks.ts
+var e = (e = [], t) => {
+	switch (t.type) {
+		case "CHANGE_MARKS":
+			if (Array.isArray(t.marks)) return t.marks;
+			throw Error("marks must be an array");
+		default: return e;
+	}
+};
+//#endregion
+export { e as default };

package/dist/container/middleware.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/container/middleware.js
+ * @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.
+ */
+export declare const getLastAction: () => any;
+export declare const lastActionMiddleware: () => (next: any) => (action: any) => any;

package/dist/container/middleware.js

@@ -0,0 +1,4 @@
+//#region src/container/middleware.ts
+var e = () => (e) => (t) => e(t);
+//#endregion
+export { e as lastActionMiddleware };