@pie-lib/graphing 4.0.5-next.29 → 4.0.5-next.30

package/dist/tools/parabola/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/parabola/index.ts
+var i = r("pie-lib:graphing:parabola"), a = () => ({
+	type: "parabola",
+	Component: n,
+	complete: (e, t) => ({
+		...t,
+		building: !1,
+		closed: !0
+	}),
+	addPoint: (n, r) => {
+		if (i("add point to parabola model: ", n, "mark: ", r), r && (e(r.root, n) || t(r.root, n))) return r;
+		if (!r) return {
+			type: "parabola",
+			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/point/component.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/point/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';
+export declare class Point extends React.Component {
+    static propTypes: {
+        mark: import("prop-types").Requireable<any>;
+        onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+        onDragStart: import("prop-types").Requireable<(...args: any[]) => any>;
+        onDragStop: import("prop-types").Requireable<(...args: any[]) => any>;
+        graphProps: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+            scale: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+                x: import("prop-types").Validator<(...args: any[]) => any>;
+                y: import("prop-types").Validator<(...args: any[]) => any>;
+            }>>>;
+            snap: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+                x: import("prop-types").Validator<(...args: any[]) => any>;
+                y: import("prop-types").Validator<(...args: any[]) => any>;
+            }>>>;
+            domain: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+                min: import("prop-types").Validator<number>;
+                max: import("prop-types").Validator<number>;
+                step: import("prop-types").Requireable<number>;
+            }>>>;
+            range: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+                min: import("prop-types").Validator<number>;
+                max: import("prop-types").Validator<number>;
+                step: import("prop-types").Requireable<number>;
+            }>>>;
+            size: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+                width: import("prop-types").Validator<number>;
+                height: import("prop-types").Validator<number>;
+            }>>>;
+        }>>>;
+    };
+    static defaultProps: {};
+    constructor(props: any);
+    move: any;
+    startDrag: any;
+    stopDrag: any;
+    labelChange: any;
+    clickPoint: any;
+    render(): React.JSX.Element;
+}
+export default Point;

package/dist/tools/point/component.js

@@ -0,0 +1,85 @@
+import { BasePoint as e } from "../shared/point/index.js";
+import { ToolPropTypeFields as t } from "../shared/types.js";
+import n from "../../mark-label.js";
+import r from "react";
+import { isEmpty as i, isEqual as a } from "@pie-element/shared-lodash";
+import { types as o } from "@pie-lib/plot";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+import l from "react-dom";
+//#region src/tools/point/component.tsx
+var u = class extends r.Component {
+	static propTypes = {
+		graphProps: o.GraphPropsType.isRequired,
+		...t
+	};
+	static defaultProps = {};
+	constructor(e) {
+		super(e), this.state = {};
+	}
+	move = (e) => {
+		let t = {
+			...this.state.mark,
+			...e
+		};
+		this.setState({ mark: t });
+	};
+	startDrag = () => {
+		let { onDragStart: e } = this.props, t = { ...this.props.mark };
+		t.label === "" && delete t.label, this.setState({ mark: t }), e && e();
+	};
+	stopDrag = () => {
+		let { onChange: e, onDragStop: t } = this.props, n = { ...this.state.mark };
+		this.setState({ mark: void 0 }, () => {
+			a(this.props.mark, n) || e(this.props.mark, n), t && t();
+		});
+	};
+	labelChange = (e) => {
+		let { onChange: t } = this.props, n = {
+			...this.props.mark,
+			label: e
+		};
+		(!e || i(e)) && delete n.label, this.setState({ mark: n }, () => {
+			t(this.props.mark, n);
+		});
+	};
+	clickPoint = () => {
+		let { labelModeEnabled: e, onChange: t, onClick: n, mark: r } = this.props;
+		if (!e) {
+			n(r);
+			return;
+		}
+		r.disabled || (t(r, {
+			label: "",
+			...r
+		}), setTimeout(() => {
+			this.input && this.input.focus();
+		}, 0));
+	};
+	render() {
+		let { coordinatesOnHover: t, graphProps: i, labelNode: a, labelModeEnabled: o } = this.props, u = this.state.mark ? this.state.mark : this.props.mark;
+		return /* @__PURE__ */ c(r.Fragment, { children: [/* @__PURE__ */ s(e, {
+			...u,
+			coordinatesOnHover: t,
+			graphProps: i,
+			labelNode: a,
+			onDrag: this.move,
+			onDragStart: this.startDrag,
+			onDragStop: this.stopDrag,
+			onClick: this.clickPoint,
+			onTouchStart: (e) => {
+				e.stopPropagation(), this.clickPoint();
+			},
+			onTouchEnd: (e) => {
+				e.stopPropagation(), this.clickPoint();
+			}
+		}), a && Object.prototype.hasOwnProperty.call(u, "label") && l.createPortal(/* @__PURE__ */ s(n, {
+			inputRef: (e) => this.input = e,
+			disabled: !o,
+			mark: u,
+			graphProps: i,
+			onChange: this.labelChange
+		}), a)] });
+	}
+};
+//#endregion
+export { u as default };

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

@@ -0,0 +1,15 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/point/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 Point from './component.js';
+export declare const tool: () => {
+    label: string;
+    type: string;
+    Component: typeof Point;
+    addPoint: (point: any) => any;
+};

package/dist/tools/point/index.js

@@ -0,0 +1,13 @@
+import e from "./component.js";
+//#region src/tools/point/index.ts
+var t = () => ({
+	label: "Point",
+	type: "point",
+	Component: e,
+	addPoint: (e) => ({
+		type: "point",
+		...e
+	})
+});
+//#endregion
+export { t as tool };

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

@@ -0,0 +1,120 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/polygon/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 const buildLines: (points: any, closed: any) => {
+    from: unknown;
+    to: unknown;
+}[];
+export declare const swap: (arr: any, ...rest: any[]) => any[];
+export declare class RawBaseComponent extends React.Component {
+    static propTypes: {
+        classes: PropTypes.Requireable<object>;
+        className: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        correctness: PropTypes.Requireable<string>;
+        points: PropTypes.Requireable<(PropTypes.InferProps<{
+            x: PropTypes.Validator<number>;
+            y: PropTypes.Validator<number>;
+        }> | null | undefined)[]>;
+        closed: PropTypes.Requireable<boolean>;
+        coordinatesOnHover: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Validator<(...args: any[]) => any>;
+        onClosePolygon: PropTypes.Validator<(...args: any[]) => any>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStop: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: 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>;
+            }>>>;
+        }>>>;
+        isToolActive: PropTypes.Requireable<boolean>;
+        middle: PropTypes.Requireable<object>;
+        labelNode: PropTypes.Requireable<object>;
+        labelModeEnabled: PropTypes.Requireable<boolean>;
+        limitLabeling: PropTypes.Requireable<boolean>;
+        onChangeLabelProps: PropTypes.Requireable<(...args: any[]) => any>;
+        onSetMiddleLabel: PropTypes.Requireable<(...args: any[]) => any>;
+        onChangeProps: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        points: never[];
+    };
+    dragPoint: any;
+    dragLine: any;
+    dragPoly: any;
+    close: any;
+    labelChange: any;
+    clickPoint: any;
+    input: {};
+    render(): React.JSX.Element;
+}
+export declare const BaseComponent: typeof RawBaseComponent;
+export default class Component 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>;
+            }>>>;
+        }>>>;
+        mark: PropTypes.Requireable<any>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStart: PropTypes.Requireable<(...args: any[]) => any>;
+        onDragStop: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {};
+    constructor(props: any);
+    change: any;
+    changeProps: any;
+    changeLabelProps: any;
+    setMiddleLabel: any;
+    closePolygon: any;
+    dragStart: () => void;
+    dragStop: any;
+    render(): React.JSX.Element;
+}

package/dist/tools/polygon/component.js

@@ -0,0 +1,262 @@
+import { __toESM as e } from "../../_virtual/_rolldown/runtime.js";
+import { require_browser as t } from "../../node_modules/.bun/invariant@2.2.4/node_modules/invariant/browser.js";
+import { equalPoints as n, getMiddleOfTwoPoints as r, getRightestPoints as i, stripEmptyLabel as a } from "../../utils.js";
+import { BasePoint as o } from "../shared/point/index.js";
+import { ToolPropTypeFields as s } from "../shared/types.js";
+import c from "../../mark-label.js";
+import l from "./line.js";
+import u, { Polygon as d } from "./polygon.js";
+import f from "react";
+import p from "prop-types";
+import { chunk as m, initial as h, isEmpty as g } from "@pie-element/shared-lodash";
+import { types as _ } from "@pie-lib/plot";
+import v from "debug";
+import { jsx as y, jsxs as b } from "react/jsx-runtime";
+import x from "react-dom";
+//#region src/tools/polygon/component.tsx
+var S = /* @__PURE__ */ e(t(), 1), C = v("pie-lib:graphing:polygon"), w = (e, t) => {
+	let n = m(e.reduce((t, n, r) => {
+		t.push({
+			...n,
+			index: r
+		});
+		let i = r === e.length - 1 ? 0 : r + 1;
+		return t.push({
+			...e[i],
+			index: i
+		}), t;
+	}, []), 2).map(([e, t]) => ({
+		from: e,
+		to: t
+	}));
+	return t ? n : h(n);
+}, T = (e, ...t) => m(t, 2).reduce((e, t) => {
+	if (t.length === 2) {
+		let [n, r] = t;
+		(0, S.default)(Number.isFinite(n.index), "Index must be defined");
+		let i = n.index;
+		return i >= 0 && e.splice(i, 1, r), e;
+	} else return e;
+}, [...e]), E = class extends f.Component {
+	static propTypes = {
+		classes: p.object,
+		className: p.string,
+		disabled: p.bool,
+		correctness: p.string,
+		points: p.arrayOf(_.PointType),
+		closed: p.bool,
+		coordinatesOnHover: p.bool,
+		onChange: p.func.isRequired,
+		onClosePolygon: p.func.isRequired,
+		onDragStart: p.func,
+		onDragStop: p.func,
+		onClick: p.func,
+		graphProps: _.GraphPropsType.isRequired,
+		isToolActive: p.bool,
+		middle: p.object,
+		labelNode: p.object,
+		labelModeEnabled: p.bool,
+		limitLabeling: p.bool,
+		onChangeLabelProps: p.func,
+		onSetMiddleLabel: p.func,
+		onChangeProps: p.func
+	};
+	static defaultProps = { points: [] };
+	dragPoint = (e, t, r) => {
+		C("[dragPoint] from, to:", t, r);
+		let { onChange: i, points: a } = this.props, o = [...a], s = !!(a || []).find((e) => n(e, r));
+		n(t, r) || s || (a[e].label && (r.label = a[e].label), o.splice(e, 1, r), i(o));
+	};
+	dragLine = (e, t) => {
+		C("[dragLine]: ", e, t);
+		let { onChange: n } = this.props;
+		e.from.label && (t.from.label = e.from.label), e.to.label && (t.to.label = e.to.label), n(T(this.props.points, e.from, t.from, e.to, t.to));
+	};
+	dragPoly = (e, t) => {
+		C("[dragPoly] ", e, t);
+		let { onChange: n } = this.props;
+		t.forEach((n, r) => {
+			e[r].label && (t[r].label = e[r].label);
+		}), n(t);
+	};
+	close = () => {
+		let { points: e, onClosePolygon: t } = this.props;
+		C("[close] ..."), e.length >= 3 ? t() : C("[close] - nope");
+	};
+	labelChange = (e, t) => {
+		let { points: n, onChangeProps: r } = this.props, i = { ...e };
+		(!e.label || g(e.label)) && delete i.label;
+		let a = [...n];
+		a.splice(t, 1, i), r(a);
+	};
+	clickPoint = (e, t, n) => {
+		let { closed: o, disabled: s, middle: c, onClick: l, isToolActive: u, labelModeEnabled: d, limitLabeling: f, onSetMiddleLabel: p, points: m } = this.props;
+		if (d) {
+			if (s || f) return;
+			if (m && t === m.length) {
+				let { a: t, b: n } = i(m);
+				p({
+					label: "",
+					...e,
+					...r(t, n)
+				}, m.map(a));
+			} else {
+				let n = m.map(a);
+				n.splice(t, 1, {
+					label: "",
+					...e
+				}), p(c && a(c), n);
+			}
+			setTimeout(() => {
+				this.input[t] && this.input[t].focus();
+			}, 0);
+			return;
+		}
+		if (u && !o && t === 0) {
+			this.close();
+			return;
+		}
+		l(e || n);
+	};
+	input = {};
+	render() {
+		let { closed: e, coordinatesOnHover: t, correctness: n, disabled: r, graphProps: i, onChangeLabelProps: a, onDragStart: s, onDragStop: p, points: m, middle: h, labelNode: g, labelModeEnabled: _ } = this.props, v = w(m, e), S = {
+			onDragStart: s,
+			onDragStop: p,
+			graphProps: i,
+			disabled: r,
+			correctness: n
+		}, C = m && m.length || 0, T = null;
+		return g && h && Object.prototype.hasOwnProperty.call(h, "label") && (T = x.createPortal(/* @__PURE__ */ y(c, {
+			inputRef: (e) => this.input[C] = e,
+			disabled: r || !_,
+			mark: h,
+			graphProps: i,
+			onChange: (e) => a({
+				...h,
+				label: e
+			})
+		}), g)), /* @__PURE__ */ b("g", { children: [
+			e ? /* @__PURE__ */ b(f.Fragment, { children: [/* @__PURE__ */ y(u, {
+				points: m,
+				onDrag: this.dragPoly.bind(this, m),
+				closed: e,
+				...S,
+				onClick: this.clickPoint.bind(this, h, C)
+			}), T] }) : /* @__PURE__ */ y(d, {
+				points: m,
+				graphProps: i,
+				closed: e
+			}),
+			(v || []).map((e, t) => /* @__PURE__ */ y(l, {
+				from: e.from,
+				to: e.to,
+				onDrag: this.dragLine.bind(this, e),
+				...S,
+				onClick: this.clickPoint.bind(this, h, C)
+			}, `line-${t}`)),
+			(m || []).map((e, n) => [/* @__PURE__ */ y(o, {
+				coordinatesOnHover: t,
+				labelNode: g,
+				x: e.x,
+				y: e.y,
+				onDrag: this.dragPoint.bind(this, n, e),
+				...S,
+				onClick: this.clickPoint.bind(this, e, n)
+			}, `point-${n}`), g && Object.prototype.hasOwnProperty.call(e, "label") ? x.createPortal(/* @__PURE__ */ y(c, {
+				inputRef: (e) => this.input[n] = e,
+				disabled: r || !_,
+				mark: e,
+				graphProps: i,
+				onChange: (t) => this.labelChange({
+					...e,
+					label: t
+				}, n)
+			}), g) : null])
+		] });
+	}
+}, D = class extends f.Component {
+	static propTypes = {
+		...s,
+		graphProps: _.GraphPropsType.isRequired
+	};
+	static defaultProps = {};
+	constructor(e) {
+		super(e), this.state = {};
+	}
+	change = (e) => {
+		let { mark: { middle: t } } = this.props, n = {
+			...this.state.mark,
+			points: e
+		};
+		if (t) {
+			let { a, b: o } = i(e);
+			n.middle = {
+				...t,
+				...r(a, o)
+			};
+		}
+		this.setState({ mark: n });
+	};
+	changeProps = (e) => {
+		let t = {
+			...this.props.mark,
+			points: e
+		};
+		this.props.onChange(this.props.mark, t);
+	};
+	changeLabelProps = (e) => {
+		let { mark: t, onChange: n } = this.props, r = {
+			...t.middle,
+			...e
+		};
+		(!r.label || g(r.label)) && delete r.label, n(t, {
+			...t,
+			middle: r
+		});
+	};
+	setMiddleLabel = (e, t) => {
+		let { mark: n, onChange: r } = this.props, i = {
+			...n,
+			middle: e
+		};
+		t && (i.points = t), r(n, i);
+	};
+	closePolygon = () => {
+		C("[closePolygon] ...");
+		let { onComplete: e, mark: t } = this.props;
+		e(t, {
+			...t,
+			closed: !0
+		});
+	};
+	dragStart = () => this.setState({ mark: this.props.mark });
+	dragStop = () => {
+		let { onChange: e } = this.props, t = { ...this.state.mark };
+		this.setState({ mark: void 0 }, () => {
+			e(this.props.mark, t);
+		});
+	};
+	render() {
+		let { coordinatesOnHover: e, mark: t, graphProps: n, onClick: r, isToolActive: i, labelNode: a, labelModeEnabled: o, limitLabeling: s } = this.props, { mark: c } = this.state;
+		return /* @__PURE__ */ y(E, {
+			...c || t,
+			coordinatesOnHover: e,
+			onChange: this.change,
+			onChangeLabelProps: this.changeLabelProps,
+			onSetMiddleLabel: this.setMiddleLabel,
+			onChangeProps: this.changeProps,
+			onClosePolygon: this.closePolygon,
+			onDragStart: this.dragStart,
+			onDragStop: this.dragStop,
+			onClick: r,
+			graphProps: n,
+			isToolActive: i,
+			labelNode: a,
+			labelModeEnabled: o,
+			limitLabeling: s
+		});
+	}
+};
+//#endregion
+export { D as default };

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

@@ -0,0 +1,19 @@
+/**
+ * @synced-from pie-lib/packages/graphing/src/tools/polygon/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 Polygon from './component.js';
+export declare const addPointToArray: (point: any, arr: any) => {
+    points: any;
+    closed: any;
+} | undefined;
+export declare const tool: () => {
+    type: string;
+    Component: typeof Polygon;
+    complete: (data: any, mark: any) => any;
+    addPoint: (point: any, mark: any) => any;
+};

package/dist/tools/polygon/index.js

@@ -0,0 +1,55 @@
+import { equalPoints as e } from "../../utils.js";
+import t from "./component.js";
+//#region src/tools/polygon/index.ts
+var n = (t, n) => {
+	if (n ||= [], n.length === 0) return {
+		points: [t],
+		closed: !1
+	};
+	if (n.length === 1) return e(t, n[0]) ? {
+		points: n,
+		closed: !1
+	} : {
+		points: [...n, t],
+		closed: !1
+	};
+	if (n.length >= 2) {
+		let r = e(t, n[0]);
+		return r ? {
+			points: n,
+			closed: r
+		} : n.find((n) => e(n, t)) ? {
+			points: n,
+			closed: !1
+		} : {
+			points: [...n, t],
+			closed: !1
+		};
+	}
+}, r = () => ({
+	type: "polygon",
+	Component: t,
+	complete: (e, t) => ({
+		...t,
+		building: !1,
+		closed: !0
+	}),
+	addPoint: (e, t) => {
+		if (t) {
+			let { closed: r, points: i } = n(e, t.points);
+			return {
+				...t,
+				closed: r,
+				points: i,
+				building: !r
+			};
+		} else return {
+			type: "polygon",
+			points: [e],
+			closed: !1,
+			building: !0
+		};
+	}
+});
+//#endregion
+export { r as tool };