@pie-lib/graphing 4.0.5-next.3 → 4.0.5-next.31

package/dist/toggle-bar.js

@@ -0,0 +1,155 @@
+import { allTools as e } from "./tools/index.js";
+import t from "react";
+import n from "prop-types";
+import { styled as r } from "@mui/material/styles";
+import { jsx as i } from "react/jsx-runtime";
+import { color as a } from "@pie-lib/render-ui";
+import o from "@mui/material/Button";
+import { DragProvider as s } from "@pie-lib/drag";
+import { useDraggable as c, useDroppable as l } from "@dnd-kit/core";
+import { CSS as u } from "@dnd-kit/utilities";
+import { arrayMove as d } from "@dnd-kit/sortable";
+import f from "@pie-lib/translator";
+//#region src/toggle-bar.tsx
+var { translator: p } = f, m = r(o, { shouldForwardProp: (e) => !["selected"].includes(e) })(({ selected: e, disabled: t }) => ({
+	color: a.text(),
+	backgroundColor: a.background(),
+	border: `1px solid ${a.buttonBorder()}`,
+	"&:hover": { backgroundColor: a.buttonHoverBg() },
+	...e && { border: `1px solid ${a.secondary()}` },
+	...!e && { "& span": { color: a.primary() } },
+	...t && {
+		"& span": { color: a.primary() },
+		backgroundColor: a.disabled()
+	}
+})), h = (e) => {
+	let { disabled: t, className: n, selected: r, value: a, onClick: o, language: s } = e, c = a.toLowerCase();
+	return /* @__PURE__ */ i(m, {
+		size: "small",
+		disabled: t,
+		className: n,
+		selected: r,
+		value: a,
+		variant: "outlined",
+		onClick: (e) => o({
+			...e,
+			buttonValue: a
+		}),
+		children: p.t(`graphing.${c}`, { lng: s })
+	}, a);
+};
+h.propTypes = {
+	disabled: n.bool,
+	className: n.string,
+	disabledClassName: n.string,
+	selected: n.bool,
+	value: n.string,
+	onClick: n.func,
+	language: n.string
+};
+var g = r("div")(() => ({
+	display: "flex",
+	flexWrap: "wrap"
+})), _ = r(h)(({ theme: e }) => ({
+	marginRight: e.spacing(.5),
+	marginBottom: e.spacing(.5),
+	color: a.text()
+})), v = r("div")({ position: "relative" }), y = class extends t.Component {
+	static propTypes = {
+		className: n.string,
+		options: n.arrayOf(n.string),
+		selectedToolType: n.string,
+		disabled: n.bool,
+		draggableTools: n.bool,
+		onChange: n.func,
+		onChangeToolsOrder: n.func,
+		language: n.string
+	};
+	static defaultProps = {};
+	select = (e) => this.props.onChange(e.buttonValue || e.target.textContent);
+	moveTool = (e, t) => {
+		let { options: n, onChangeToolsOrder: r } = this.props;
+		r(d(n, e, t));
+	};
+	handleDragEnd = (e) => {
+		let { active: t, over: n } = e;
+		if (!n || !t) return;
+		let r = t.data.current, i = n.data.current;
+		if (r?.type === "tool" && i?.type === "tool") {
+			let e = r.index, t = i.index;
+			e !== t && this.moveTool(e, t);
+		}
+	};
+	render() {
+		let { className: n, disabled: r, options: a, selectedToolType: o, draggableTools: c, language: l } = this.props;
+		return /* @__PURE__ */ i(s, {
+			onDragEnd: this.handleDragEnd,
+			children: /* @__PURE__ */ i(g, {
+				className: n,
+				children: (a || []).map((n, a) => {
+					if ((e || []).includes(n)) {
+						let e = n === o, s = t.createRef();
+						return /* @__PURE__ */ i(b, {
+							index: a,
+							value: n,
+							draggable: c,
+							moveTool: this.moveTool,
+							toolRef: s,
+							children: /* @__PURE__ */ i(_, {
+								disabled: r,
+								disableRipple: !0,
+								onClick: this.select,
+								value: n,
+								selected: e,
+								language: l
+							})
+						}, n);
+					}
+				})
+			})
+		});
+	}
+};
+function b({ children: e, index: t, draggable: n, toolRef: r, value: a }) {
+	let { attributes: o, listeners: s, setNodeRef: d, transform: f, transition: p, isDragging: m } = c({
+		id: `tool-${a}-${t}`,
+		disabled: !n,
+		data: {
+			type: "tool",
+			index: t,
+			value: a
+		}
+	}), { setNodeRef: h } = l({
+		id: `drop-tool-${a}-${t}`,
+		data: {
+			type: "tool",
+			index: t,
+			accepts: ["tool"]
+		}
+	});
+	return /* @__PURE__ */ i(v, {
+		ref: (e) => {
+			d(e), h(e), r?.current && (r.current = e);
+		},
+		style: {
+			transform: u.Transform.toString(f),
+			transition: p,
+			opacity: m ? .5 : 1
+		},
+		children: /* @__PURE__ */ i("div", {
+			...o,
+			...s,
+			children: e
+		})
+	});
+}
+b.propTypes = {
+	children: n.node,
+	index: n.number,
+	draggable: n.bool,
+	moveTool: n.func,
+	toolRef: n.object,
+	value: n.string
+};
+//#endregion
+export { y as default };

package/dist/tool-menu.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tool-menu.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 ToolMenu extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        currentToolType: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        draggableTools: PropTypes.Requireable<boolean>;
+        labelModeEnabled: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onChangeTools: PropTypes.Requireable<(...args: any[]) => any>;
+        toolbarTools: PropTypes.Requireable<(string | null | undefined)[]>;
+        language: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        toolbarTools: never[];
+    };
+    updateToolsOrder: any;
+    render(): React.JSX.Element;
+}
+export default ToolMenu;

package/dist/tool-menu.js

@@ -0,0 +1,41 @@
+import e from "./node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import t from "./toggle-bar.js";
+import n from "react";
+import r from "prop-types";
+import { jsx as i } from "react/jsx-runtime";
+//#region src/tool-menu.tsx
+var a = class extends n.Component {
+	static propTypes = {
+		className: r.string,
+		currentToolType: r.string,
+		disabled: r.bool,
+		draggableTools: r.bool,
+		labelModeEnabled: r.bool,
+		onChange: r.func,
+		onChangeTools: r.func,
+		toolbarTools: r.arrayOf(r.string),
+		language: r.string
+	};
+	static defaultProps = { toolbarTools: [] };
+	updateToolsOrder = (e) => {
+		let { onChangeTools: t } = this.props;
+		t(e);
+	};
+	render() {
+		let { className: n, currentToolType: r, disabled: a, draggableTools: o, onChange: s, language: c } = this.props, { toolbarTools: l } = this.props;
+		return /* @__PURE__ */ i("div", {
+			className: e(n),
+			children: /* @__PURE__ */ i(t, {
+				disabled: a,
+				draggableTools: o,
+				options: l,
+				selectedToolType: r,
+				onChange: s,
+				onChangeToolsOrder: (e) => this.updateToolsOrder(e),
+				language: c
+			})
+		});
+	}
+};
+//#endregion
+export { a as default };

package/dist/tools/absolute/component.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/absolute/component.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.
+ */
+declare const Component: {
+    (props: any): import("react").JSX.Element;
+    propTypes: {
+        onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+        mark: import("prop-types").Requireable<object>;
+    };
+};
+export default Component;

package/dist/tools/absolute/component.js

@@ -0,0 +1,15 @@
+import { rootEdgeComponent as e, withRootEdge as t } from "../shared/line/with-root-edge.js";
+import n from "debug";
+import { absoluteFromTwoPoints as r, buildDataPoints as i } from "@pie-lib/graphing-utils";
+//#region src/tools/absolute/component.tsx
+var a = n("pie-lib:graphing:absolute"), o = e(t((e) => {
+	let { root: t, edge: n, graphProps: o } = e, { domain: s, range: c } = o, l = n && n.x === t.x ? [] : i(s, c, t, n, r(t, n), !0);
+	return a("dataPoints:", l), {
+		root: e.root,
+		edge: e.edge,
+		dataPoints: l,
+		enableCurve: !1
+	};
+}));
+//#endregion
+export { o as default };

package/dist/tools/absolute/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/absolute/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.
+ */
+export declare const tool: () => {
+    type: string;
+    Component: {
+        (props: any): import("react").JSX.Element;
+        propTypes: {
+            onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+            mark: import("prop-types").Requireable<object>;
+        };
+    };
+    complete: (data: any, mark: any) => any;
+    addPoint: (point: any, mark: any) => any;
+};

package/dist/tools/absolute/index.js

@@ -0,0 +1,32 @@
+import { equalPoints as e, sameAxes as t } from "../../utils.js";
+import n from "./component.js";
+import r from "debug";
+//#region src/tools/absolute/index.ts
+var i = r("pie-lib:graphing:absolute"), a = () => ({
+	type: "absolute",
+	Component: n,
+	complete: (e, t) => ({
+		...t,
+		building: !1,
+		closed: !0
+	}),
+	addPoint: (n, r) => {
+		if (i("add point to absolute model: ", n, "mark: ", r), r && (e(r.root, n) || t(r.root, n))) return r;
+		if (!r) return {
+			type: "absolute",
+			root: n,
+			edge: void 0,
+			closed: !1,
+			building: !0
+		};
+		if (r && !r.root) throw Error("no root - should never happen");
+		return {
+			...r,
+			edge: n,
+			closed: !0,
+			building: !1
+		};
+	}
+});
+//#endregion
+export { a as tool };

package/dist/tools/circle/bg-circle.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/circle/bg-circle.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';
+declare class RawCircle extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        correctness: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        x: PropTypes.Validator<number>;
+        y: PropTypes.Validator<number>;
+        radius: PropTypes.Requireable<number>;
+        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>;
+            }>>>;
+        }>>>;
+    };
+    render(): React.JSX.Element;
+}
+export declare const BgCircle: typeof RawCircle;
+declare const _default: {
+    new (props: any): {
+        grid: any;
+        onStart: any;
+        position: any;
+        tiny: any;
+        getScaledBounds: any;
+        getClientPoint: any;
+        skipDragOutsideOfBounds: any;
+        onDrag: any;
+        getDelta: any;
+        applyDelta: any;
+        onStop: any;
+        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<{}>;
+        state: 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;
+        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
+        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: {
+        disabled: PropTypes.Requireable<boolean>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDrag: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStop: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onMove: PropTypes.Requireable<(...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>;
+            }>>>;
+        }>>>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/tools/circle/bg-circle.js

@@ -0,0 +1,72 @@
+import { bounds as e, point as t } from "../../utils.js";
+import n from "../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { correct as r, disabled as i, disabledSecondary as a, incorrect as o, missing as s } from "../shared/styles.js";
+import c from "react";
+import l from "prop-types";
+import { gridDraggable as u, types as d } from "@pie-lib/plot";
+import { styled as f } from "@mui/material/styles";
+import { jsx as p } from "react/jsx-runtime";
+import { color as m } from "@pie-lib/render-ui";
+//#region src/tools/circle/bg-circle.tsx
+var h = class extends c.Component {
+	static propTypes = {
+		className: l.string,
+		correctness: l.string,
+		disabled: l.bool,
+		x: l.number.isRequired,
+		y: l.number.isRequired,
+		radius: l.number,
+		graphProps: d.GraphPropsType.isRequired
+	};
+	render() {
+		let { disabled: e, className: t, correctness: r, x: i, y: a, radius: o, graphProps: s, ...c } = this.props, { scale: l } = s, u = Math.abs(l.x(i + o) - l.x(i)), d = Math.abs(l.y(a + o) - l.y(a));
+		return /* @__PURE__ */ p(_, {
+			className: n(t, e && "disabledSecondary", r),
+			cx: l.x(i),
+			cy: l.y(a),
+			rx: u,
+			ry: d,
+			...c
+		});
+	}
+}, g = (e) => ({
+	...e("stroke"),
+	"&:hover": {
+		strokeWidth: 3,
+		...e("stroke")
+	}
+}), _ = f("ellipse")(() => ({
+	fill: "transparent",
+	stroke: m.defaults.BLACK,
+	strokeWidth: 3,
+	transition: "stroke 200ms ease-in, stroke-width 200ms ease-in",
+	"&:hover": {
+		strokeWidth: 6,
+		stroke: m.defaults.PRIMARY_DARK
+	},
+	"&.disabled": g(i),
+	"&.disabledSecondary": g(a),
+	"&.correct": g(r),
+	"&.incorrect": g(o),
+	"&.missing": g(s)
+})), v = h, y = u({
+	bounds: (t, { domain: n, range: r }) => {
+		let { x: i, y: a } = t;
+		return e({
+			left: i,
+			top: a,
+			bottom: a,
+			right: i
+		}, n, r);
+	},
+	anchorPoint: (e) => {
+		let { x: t, y: n } = e;
+		return {
+			x: t,
+			y: n
+		};
+	},
+	fromDelta: (e, n) => t(e).add(t(n))
+})(v);
+//#endregion
+export { y as default };

package/dist/tools/circle/component.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/circle/component.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 RawBaseCircle extends React.Component {
+    static propTypes: {
+        building: PropTypes.Requireable<boolean>;
+        className: PropTypes.Requireable<string>;
+        coordinatesOnHover: PropTypes.Requireable<boolean>;
+        correctness: PropTypes.Requireable<string>;
+        from: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }>>;
+        disabled: PropTypes.Requireable<boolean>;
+        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.Validator<(...args: any[]) => any>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStop: PropTypes.Requireable<(...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>;
+            }>>>;
+        }>>>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        labelNode: PropTypes.Requireable<object>;
+        labelModeEnabled: PropTypes.Requireable<boolean>;
+        changeMarkProps: PropTypes.Requireable<(...args: any[]) => any>;
+        limitLabeling: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        onClick: () => {};
+    };
+    onChangePoint: any;
+    dragFrom: any;
+    dragTo: any;
+    dragCircle: any;
+    labelChange: any;
+    clickPoint: any;
+    input: {};
+    render(): React.JSX.Element;
+}
+export declare const BaseCircle: typeof RawBaseCircle;
+declare const Component: {
+    (props: any): React.JSX.Element;
+    propTypes: {
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        mark: PropTypes.Requireable<object>;
+    };
+};
+export default Component;