@pie-lib/graphing 4.1.0-beta.7 → 5.0.0-next.36

package/dist/tools/shared/line/index.js

@@ -0,0 +1,332 @@
+import { equalPoints as e, getMiddleOfTwoPoints as t, sameAxes as n, stripEmptyLabel as r } from "../../../utils.js";
+import { correct as i, disabled as a, disabledSecondary as o, incorrect as s, missing as c } from "../styles.js";
+import { BasePoint as l } from "../point/index.js";
+import { MarkLabel as u } from "../../../mark-label.js";
+import d from "react";
+import f from "prop-types";
+import { cloneDeep as p, isEmpty as m, isEqual as h } from "@pie-element/shared-lodash";
+import { gridDraggable as g, trig as _, types as v, utils as y } from "@pie-lib/plot";
+import { jsx as b, jsxs as x } from "react/jsx-runtime";
+import { styled as S } from "@mui/material/styles";
+import { color as C } from "@pie-lib/render-ui";
+import w from "react-dom";
+//#region src/tools/shared/line/index.tsx
+var T = S("g")(({ disabled: e, correctness: t }) => ({
+	"& line:not(.hit-area)": {
+		fill: "transparent",
+		stroke: C.defaults.BLACK,
+		strokeWidth: 3,
+		transition: "stroke 200ms ease-in, stroke-width 200ms ease-in",
+		"&:hover": {
+			strokeWidth: 6,
+			stroke: C.defaults.PRIMARY_DARK
+		}
+	},
+	...e && { "& line:not(.hit-area)": {
+		...o("stroke"),
+		strokeWidth: 2
+	} },
+	...t === "correct" && { "& line:not(.hit-area)": { ...i("stroke") } },
+	...t === "incorrect" && { "& line:not(.hit-area)": { ...s("stroke") } },
+	...t === "missing" && { "& line:not(.hit-area)": {
+		...c("stroke"),
+		strokeWidth: 1,
+		strokeDasharray: "4 3"
+	} }
+})), E = (t, n) => () => ({
+	type: t,
+	Component: n,
+	addPoint: (n, r) => r && e(r.root, n) ? r : r ? e(n, r.from) ? { ...r } : {
+		...r,
+		building: !1,
+		to: n
+	} : {
+		type: t,
+		building: !0,
+		from: n
+	}
+}), D = (e) => class extends d.Component {
+	static propTypes = {
+		...v.ToolPropTypeFields,
+		graphProps: v.GraphPropsType.isRequired,
+		limitLabeling: f.bool,
+		changeMarkProps: f.func,
+		disabled: f.bool,
+		from: v.PointType,
+		to: v.PointType,
+		labelModeEnabled: f.bool,
+		onClick: f.func
+	};
+	constructor(e) {
+		super(e), this.state = {};
+	}
+	startDrag = () => {
+		let { onDragStart: e } = this.props;
+		this.setState({ mark: { ...this.props.mark } }), e && e();
+	};
+	stopDrag = () => {
+		let { onChange: e, mark: t, onDragStop: r } = this.props, i = { ...this.state.mark };
+		this.setState({ mark: void 0 }, () => {
+			let { type: a } = i, o = a && (a === "parabola" || a === "sine" || a === "absolute" || a === "exponential") && n(i.from, i.to);
+			!o && a && a === "exponential" && i.from && i.to && (o = i.from.y === 0 || i.to.y === 0 || i.from.y * i.to.y < 0), !h(t, i) && !o && e(t, i), r && r();
+		});
+	};
+	changeMark = ({ from: e, to: t, middle: n }) => {
+		let r = {
+			...this.state.mark,
+			from: e,
+			to: t
+		};
+		n && (r = {
+			...r,
+			middle: n
+		}), this.setState({ mark: r });
+	};
+	changeMarkProps = ({ from: e, to: t, middle: n }) => {
+		let { onChange: r, mark: i } = this.props, a = {
+			...i,
+			...this.state.mark
+		};
+		e && (a = {
+			...a,
+			from: e
+		}), t && (a = {
+			...a,
+			to: t
+		}), n && (a = {
+			...a,
+			middle: n
+		}), h(i, a) || r(i, a);
+	};
+	render() {
+		let { graphProps: t, onClick: n, labelNode: r, labelModeEnabled: i, coordinatesOnHover: a, limitLabeling: o } = this.props, s = this.state.mark ? this.state.mark : this.props.mark, c = p(s.from), l = p(s.to), u = p(s.middle);
+		return c && s.isBackground && (c.disabled = !0), l && s.isBackground && (l.disabled = !0), u && s.isBackground && (u.disabled = !0), /* @__PURE__ */ b(e, {
+			disabled: s.disabled,
+			coordinatesOnHover: a,
+			correctness: s.correctness,
+			from: c,
+			to: l,
+			middle: u,
+			graphProps: t,
+			onChange: this.changeMark,
+			changeMarkProps: this.changeMarkProps,
+			onClick: n,
+			onDragStart: this.startDrag,
+			onDragStop: this.stopDrag,
+			labelNode: r,
+			labelModeEnabled: i,
+			limitLabeling: o
+		});
+	}
+}, O = () => ({
+	bounds: (e, { domain: t, range: n }) => {
+		let r = y.lineToArea(e.from, e.to);
+		return y.bounds(r, t, n);
+	},
+	anchorPoint: (e) => {
+		let { from: t } = e;
+		return t;
+	},
+	fromDelta: (e, t) => {
+		let { from: n, to: r } = e;
+		return {
+			from: y.point(n).add(y.point(t)),
+			to: y.point(r).add(y.point(t))
+		};
+	}
+}), k = (n, i) => {
+	let a = g(O())(n), o = i && i.from ? i.from : l, s = i && i.to ? i.to : l;
+	class c extends d.Component {
+		static propTypes = {
+			coordinatesOnHover: f.bool,
+			graphProps: v.GraphPropsType,
+			from: v.PointType,
+			to: v.PointType,
+			middle: v.PointType,
+			onChange: f.func,
+			onDragStart: f.func,
+			onDragStop: f.func,
+			onClick: f.func,
+			correctness: f.string,
+			disabled: f.bool,
+			limitLabeling: f.bool,
+			changeMarkProps: f.func,
+			labelModeEnabled: f.bool,
+			labelNode: f.object
+		};
+		state = { editingLabel: null };
+		componentDidUpdate(e) {
+			e.labelModeEnabled && !this.props.labelModeEnabled && this.state.editingLabel !== null && this.setState({ editingLabel: null });
+		}
+		onChangePoint = (n) => {
+			let { middle: r, onChange: i } = this.props, { from: a, to: o } = n;
+			e(a, o) || (r && (n.middle = {
+				...r,
+				...t(a, o)
+			}), i(n));
+		};
+		dragComp = ({ from: e, to: n }) => {
+			let { from: r, to: i, onChange: a, middle: o } = this.props;
+			r.label && (e.label = r.label), i.label && (n.label = i.label);
+			let s = {
+				from: e,
+				to: n
+			};
+			o && (s.middle = {
+				...o,
+				...t(e, n)
+			}), a(s);
+		};
+		dragFrom = (t) => {
+			let { from: n, to: r } = this.props;
+			n.label && (t.label = n.label), e(t, r) || this.onChangePoint({
+				from: t,
+				to: r
+			});
+		};
+		dragTo = (t) => {
+			let { from: n, to: r } = this.props;
+			r.label && (t.label = r.label), e(n, t) || this.onChangePoint({
+				from: n,
+				to: t
+			});
+		};
+		labelChange = (e, t) => {
+			let { changeMarkProps: n } = this.props, r = { ...e };
+			(!e.label || m(e.label)) && delete r.label, n({ [t]: r });
+		};
+		stopEditingLabel = () => {
+			this.state.editingLabel !== null && this.setState({ editingLabel: null });
+		};
+		clickPoint = (e, n, i) => {
+			let { changeMarkProps: a, disabled: o, from: s, to: c, middle: l, labelModeEnabled: u, limitLabeling: d, onClick: f } = this.props;
+			if (!u) {
+				f(e || i);
+				return;
+			}
+			o || d || (n === "middle" && !e && s && c && (e = {
+				...e,
+				...t(s, c)
+			}), a({
+				from: r(s),
+				to: r(c),
+				middle: r(l),
+				[n]: {
+					label: "",
+					...e
+				}
+			}), this.setState({ editingLabel: n }));
+		};
+		input = {};
+		render() {
+			let { coordinatesOnHover: e, graphProps: t, onDragStart: n, onDragStop: r, from: i, to: c, middle: l, disabled: d, correctness: f, onClick: p, labelNode: m, labelModeEnabled: h } = this.props, { editingLabel: g } = this.state, v = {
+				graphProps: t,
+				onDragStart: n,
+				onDragStop: r,
+				disabled: d,
+				correctness: f,
+				onClick: p
+			}, y = c ? _.toDegrees(_.angle(i, c)) : 0, S = null, C = null, E = null;
+			return m && (i && Object.prototype.hasOwnProperty.call(i, "label") && (S = w.createPortal(/* @__PURE__ */ b(u, {
+				inputRef: (e) => this.input.from = e,
+				autoFocus: g === "from",
+				disabled: !h,
+				mark: i,
+				graphProps: t,
+				onBlur: this.stopEditingLabel,
+				onChange: (e) => this.labelChange({
+					...i,
+					label: e
+				}, "from")
+			}), m)), c && Object.prototype.hasOwnProperty.call(c, "label") && (C = w.createPortal(/* @__PURE__ */ b(u, {
+				inputRef: (e) => this.input.to = e,
+				autoFocus: g === "to",
+				disabled: !h,
+				mark: c,
+				graphProps: t,
+				onBlur: this.stopEditingLabel,
+				onChange: (e) => this.labelChange({
+					...c,
+					label: e
+				}, "to")
+			}), m)), l && Object.prototype.hasOwnProperty.call(l, "label") && (E = w.createPortal(/* @__PURE__ */ b(u, {
+				inputRef: (e) => this.input.middle = e,
+				autoFocus: g === "middle",
+				disabled: !h,
+				mark: l,
+				graphProps: t,
+				onBlur: this.stopEditingLabel,
+				onChange: (e) => this.labelChange({
+					...l,
+					label: e
+				}, "middle")
+			}), m))), /* @__PURE__ */ x(T, {
+				disabled: d,
+				correctness: f,
+				children: [
+					c && /* @__PURE__ */ b(a, {
+						from: i,
+						to: c,
+						middle: l,
+						onDrag: this.dragComp,
+						...v,
+						onClick: (e) => this.clickPoint(l, "middle", e)
+					}),
+					E,
+					/* @__PURE__ */ b(o, {
+						x: i.x,
+						y: i.y,
+						labelNode: m,
+						coordinatesOnHover: e,
+						onDrag: this.dragFrom,
+						...v,
+						onClick: (e) => this.clickPoint(i, "from", e)
+					}),
+					S,
+					c && /* @__PURE__ */ b(s, {
+						x: c.x,
+						y: c.y,
+						angle: y,
+						labelNode: m,
+						coordinatesOnHover: e,
+						onDrag: this.dragTo,
+						...v,
+						onClick: (e) => this.clickPoint(c, "to", e)
+					}),
+					C
+				]
+			});
+		}
+	}
+	return c;
+}, A = {
+	line: () => ({
+		fill: "transparent",
+		stroke: C.defaults.BLACK,
+		strokeWidth: 3,
+		transition: "stroke 200ms ease-in, stroke-width 200ms ease-in",
+		"&:hover": {
+			strokeWidth: 6,
+			stroke: C.defaults.PRIMARY_DARK
+		}
+	}),
+	arrow: () => ({ fill: C.defaults.BLACK }),
+	disabledArrow: () => ({ ...o() }),
+	disabledSecondary: () => ({
+		...o("stroke"),
+		strokeWidth: 2
+	}),
+	disabled: () => ({
+		...a("stroke"),
+		strokeWidth: 2
+	}),
+	correct: (e, t) => ({ ...i(t) }),
+	incorrect: (e, t) => ({ ...s(t) }),
+	missing: (e, t) => ({
+		...c(t),
+		strokeWidth: 1,
+		strokeDasharray: "4 3"
+	})
+};
+//#endregion
+export { k as lineBase, E as lineTool, D as lineToolComponent, A as styles };

package/dist/tools/shared/line/line-path.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/shared/line/line-path.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 RawLinePath extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        data: PropTypes.Requireable<((number | null | undefined)[] | null | undefined)[]>;
+        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>;
+            }>>>;
+        }>>>;
+        disabled: PropTypes.Requireable<boolean>;
+        correctness: PropTypes.Requireable<string>;
+        from: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        to: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        isDragging: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        from: {};
+        to: {};
+    };
+    render(): React.JSX.Element;
+}
+export declare const LinePath: typeof RawLinePath;

package/dist/tools/shared/line/line-path.js

@@ -0,0 +1,71 @@
+import e from "../../../node_modules/.bun/@visx_shape@4.0.0_d84c32d47042070f/node_modules/@visx/shape/esm/shapes/LinePath.js";
+import { correct as t, disabledSecondary as n, incorrect as r, missing as i } from "../styles.js";
+import a from "react";
+import o from "prop-types";
+import { types as s } from "@pie-lib/plot";
+import { jsx as c, jsxs as l } from "react/jsx-runtime";
+import { styled as u } from "@mui/material/styles";
+import { color as d } from "@pie-lib/render-ui";
+//#region src/tools/shared/line/line-path.tsx
+var f = () => ({
+	strokeWidth: 4,
+	stroke: d.defaults.BLACK
+}), p = u(e)(({ disabled: e, correctness: a }) => ({
+	fill: "none",
+	strokeWidth: 3,
+	stroke: d.black(),
+	...e && {
+		...n("stroke"),
+		strokeWidth: 2
+	},
+	...a === "correct" && t("stroke"),
+	...a === "incorrect" && r("stroke"),
+	...a === "missing" && {
+		...i("stroke"),
+		strokeWidth: 1,
+		strokeDasharray: "4 3"
+	}
+})), m = u(e)(({ theme: e, disabled: t, correctness: n, isDragging: r }) => ({
+	strokeWidth: 7,
+	fill: "none",
+	transition: "stroke-width 200ms ease-in, stroke 200ms ease-in",
+	stroke: "transparent",
+	pointerEvents: "stroke",
+	"&:hover": f(e),
+	...r && f(e),
+	...(t || n) && { pointerEvents: "none" }
+})), h = class extends a.Component {
+	static propTypes = {
+		className: o.string,
+		data: o.arrayOf(o.arrayOf(o.number)),
+		graphProps: s.GraphPropsType.isRequired,
+		disabled: o.bool,
+		correctness: o.string,
+		from: s.PointType,
+		to: s.PointType,
+		isDragging: o.bool
+	};
+	static defaultProps = {
+		from: {},
+		to: {}
+	};
+	render() {
+		let { data: e, className: t, disabled: n, correctness: r, from: i, to: o, graphProps: s, isDragging: u, ...d } = this.props;
+		return /* @__PURE__ */ l(a.Fragment, { children: [/* @__PURE__ */ c(p, {
+			data: e,
+			className: t,
+			disabled: n,
+			correctness: r,
+			...d
+		}), /* @__PURE__ */ c(m, {
+			data: e,
+			className: t,
+			isDragging: u,
+			disabled: n,
+			correctness: r,
+			...d
+		})] });
+	}
+}, g = h;
+//#endregion
+export { g as LinePath, h as RawLinePath };

package/dist/tools/shared/line/with-root-edge.d.ts

@@ -0,0 +1,148 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/shared/line/with-root-edge.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 rootEdgeToFromToWrapper: (BaseComp: any) => {
+    (props: any): React.JSX.Element;
+    propTypes: {
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        mark: PropTypes.Requireable<object>;
+    };
+};
+export declare const rootEdgeComponent: (RootEdgeComp: any) => {
+    (props: any): React.JSX.Element;
+    propTypes: {
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        mark: PropTypes.Requireable<object>;
+    };
+};
+export declare const withRootEdge: (getPoints: any) => {
+    new (props: {}): {
+        state: {
+            editingLabel: null;
+        };
+        componentDidUpdate(prevProps: any): void;
+        onChangePoint: any;
+        dragComp: ({ from: draggedFrom, to: draggedTo }: {
+            from: any;
+            to: any;
+        }) => void;
+        dragFrom: any;
+        dragTo: any;
+        labelChange: any;
+        stopEditingLabel: any;
+        clickPoint: any;
+        input: {};
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: {}, context: any): {
+        state: {
+            editingLabel: null;
+        };
+        componentDidUpdate(prevProps: any): void;
+        onChangePoint: any;
+        dragComp: ({ from: draggedFrom, to: draggedTo }: {
+            from: any;
+            to: any;
+        }) => void;
+        dragFrom: any;
+        dragTo: any;
+        labelChange: any;
+        stopEditingLabel: any;
+        clickPoint: any;
+        input: {};
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        coordinatesOnHover: PropTypes.Requireable<boolean>;
+        graphProps: PropTypes.Requireable<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>;
+            }>>>;
+        }>>;
+        from: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        to: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        middle: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStop: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        correctness: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        limitLabeling: PropTypes.Requireable<boolean>;
+        changeMarkProps: PropTypes.Requireable<(...args: any[]) => any>;
+        labelModeEnabled: PropTypes.Requireable<boolean>;
+        labelNode: PropTypes.Requireable<object>;
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/tools/shared/line/with-root-edge.js

@@ -0,0 +1,73 @@
+import { d3_shape_exports as e } from "../../../node_modules/.bun/@visx_vendor@4.0.0/node_modules/@visx/vendor/esm/d3-shape.js";
+import { LinePath as t } from "./line-path.js";
+import { lineBase as n, lineToolComponent as r } from "./index.js";
+import "react";
+import i from "prop-types";
+import { types as a } from "@pie-lib/plot";
+import { jsx as o } from "react/jsx-runtime";
+//#region src/tools/shared/line/with-root-edge.tsx
+var s = (e) => {
+	let t = { ...e };
+	return t.root = { ...e.from }, t.edge = e.to ? { ...e.to } : void 0, delete t.from, delete t.to, t;
+}, c = (e) => {
+	let t = { ...e };
+	return t.from = { ...e.root }, t.to = e.edge ? { ...e.edge } : void 0, delete t.root, delete t.edge, t;
+}, l = (e) => {
+	let t = (t) => {
+		let n = c(t.mark), r = (e, n) => {
+			t.onChange(s(e), s(n));
+		};
+		return /* @__PURE__ */ o(e, {
+			...t,
+			mark: n,
+			onChange: r
+		});
+	};
+	return t.propTypes = {
+		onChange: i.func,
+		mark: i.object
+	}, t;
+}, u = (e) => l(r(e)), d = (n) => {
+	let r = (r) => {
+		let { graphProps: i, from: a, to: s, onClick: c, onDragStart: l, onDragStop: u, onChange: d, disabled: f, correctness: p, ...m } = r, { dataPoints: h, enableCurve: g = !0 } = n({
+			graphProps: r.graphProps,
+			root: a,
+			edge: s
+		}), _ = h.map((e) => [i.scale.x(e.x), i.scale.y(e.y)]), v = {
+			onClick: c,
+			graphProps: i,
+			onDragStart: l,
+			onDragStop: u,
+			onChange: d,
+			disabled: f,
+			correctness: p
+		};
+		return g ? /* @__PURE__ */ o(t, {
+			data: _,
+			from: a,
+			to: s,
+			curve: e.curveMonotoneX,
+			...v,
+			...m
+		}) : /* @__PURE__ */ o(t, {
+			data: _,
+			from: a,
+			to: s,
+			...v,
+			...m
+		});
+	};
+	return r.propTypes = {
+		graphProps: a.GraphPropsType.isRequired,
+		from: a.PointType.isRequired,
+		to: a.PointType,
+		onClick: i.func,
+		onDragStart: i.func,
+		onDragStop: i.func,
+		onChange: i.func,
+		disabled: i.bool,
+		correctness: i.string
+	}, r;
+}, f = (e) => n(d(e));
+//#endregion
+export { u as rootEdgeComponent, l as rootEdgeToFromToWrapper, f as withRootEdge };