@pie-lib/graphing-solution-set 4.1.0-beta.9 → 5.0.0-next.20261002100925

package/dist/tools/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/src/tools/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 { tool as polygon } from './polygon/index.js';
+import { tool as line } from './line/index.js';
+declare const allTools: string[];
+declare const toolsArr: {
+    type: any;
+    Component: any;
+    addPoint: (point: any, mark: any) => any;
+}[];
+export { allTools, toolsArr, line, polygon };

package/dist/tools/index.js

@@ -0,0 +1,12 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.js";
+import { tool as t } from "./polygon/index.js";
+import { tool as n } from "./line/index.js";
+//#region src/tools/index.ts
+var r = /* @__PURE__ */ e({
+	allTools: () => i,
+	line: () => n,
+	polygon: () => t,
+	toolsArr: () => a
+}), i = ["line", "polygon"], a = [n(), t()];
+//#endregion
+export { i as allTools, n as line, t as polygon, a as toolsArr, r as tools_exports };

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

@@ -0,0 +1,113 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/src/tools/line/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 ArrowedLine: {
+    (props: any): React.JSX.Element;
+    propTypes: {
+        className: PropTypes.Requireable<string>;
+        fill: PropTypes.Requireable<string>;
+        correctness: PropTypes.Requireable<string>;
+        disabled: 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>;
+        }>>;
+        markerId: PropTypes.Requireable<string>;
+    };
+};
+declare const Component: {
+    new (props: any): {
+        startDrag: () => void;
+        stopDrag: any;
+        changeMark: any;
+        changeMarkProps: 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: {
+        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<object>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onDelete: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default Component;

package/dist/tools/line/component.js

@@ -0,0 +1,58 @@
+import { getAdjustedGraphLimits as e, thinnerShapesNeeded as t } from "../../utils.js";
+import { ArrowMarker as n, genUid as r } from "../shared/arrow-head.js";
+import { lineBase as i, lineToolComponent as a, styles as o } from "../shared/line/index.js";
+import "react";
+import s from "prop-types";
+import { trig as c, types as l } from "@pie-lib/plot";
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+import { styled as f } from "@mui/material/styles";
+//#region src/tools/line/component.tsx
+var p = f("line", { shouldForwardProp: (e) => ![
+	"fill",
+	"disabled",
+	"correctness"
+].includes(e) })(({ theme: e, fill: t, disabled: n, correctness: r }) => ({
+	...t === "Solid" ? o.line(e) : o.dashedLine(e),
+	...n && o.disabled(e),
+	...r === "correct" && o.correct(e, "stroke"),
+	...r === "incorrect" && o.incorrect(e, "stroke"),
+	...r === "missing" && o.missing(e, "stroke")
+})), m = f(n, { shouldForwardProp: (e) => !["suffix"].includes(e) })(({ theme: e, suffix: t }) => ({
+	...t === "enabled" && o.arrow(e),
+	...t === "disabled" && o.disabledArrow(e),
+	...t === "correct" && o.correct(e),
+	...t === "incorrect" && o.incorrect(e),
+	...t === "missing" && o.missing(e)
+})), h = (n) => {
+	let i = r(), { className: a, correctness: o, disabled: s, graphProps: l, fill: f = "Solid", from: h, to: g, ..._ } = n, { scale: v } = l, { domain: y, range: b } = e(l), [x, S] = c.edges(y, b)(h, g), C = o || s && "disabled" || "enabled";
+	return /* @__PURE__ */ d("g", { children: [/* @__PURE__ */ u("defs", { children: /* @__PURE__ */ u(m, {
+		size: t(l) ? 4 : 5,
+		id: `${n.markerId || i}-${C}`,
+		suffix: C
+	}) }), /* @__PURE__ */ u(p, {
+		x1: v.x(x.x),
+		y1: v.y(x.y),
+		x2: v.x(S.x),
+		y2: v.y(S.y),
+		fill: f,
+		disabled: s,
+		correctness: o,
+		className: a,
+		markerEnd: `url(#${n.markerId || i}-${C})`,
+		markerStart: `url(#${n.markerId || i}-${C})`,
+		..._
+	})] });
+};
+h.propTypes = {
+	className: s.string,
+	fill: s.string,
+	correctness: s.string,
+	disabled: s.bool,
+	graphProps: l.GraphPropsType,
+	from: l.PointType,
+	to: l.PointType,
+	markerId: s.string
+};
+var g = a(i(h));
+//#endregion
+export { h as ArrowedLine, g as default };

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

@@ -0,0 +1,13 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/src/tools/line/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: any;
+    Component: any;
+    addPoint: (point: any, mark: any) => any;
+};

package/dist/tools/line/index.js

@@ -0,0 +1,6 @@
+import { lineTool as e } from "../shared/line/index.js";
+import t from "./component.js";
+//#region src/tools/line/index.ts
+var n = e("line", t);
+//#endregion
+export { n as tool };

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

@@ -0,0 +1,117 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/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: {
+        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>;
+        isSolution: 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>;
+        onChangeLabelProps: 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;
+    closePolygon: any;
+    dragStart: () => void;
+    dragStop: any;
+    render(): React.JSX.Element;
+}

package/dist/tools/polygon/component.js

@@ -0,0 +1,194 @@
+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 } from "../../utils.js";
+import { ToolPropTypeFields as a } from "../shared/types.js";
+import o from "./polygon.js";
+import { MarkLabel as s } from "../../mark-label.js";
+import c from "react";
+import l from "prop-types";
+import { chunk as u, isEmpty as d } from "@pie-element/shared-lodash";
+import { types as f } from "@pie-lib/plot";
+import p from "debug";
+import { jsx as m } from "react/jsx-runtime";
+import h from "react-dom";
+//#region src/tools/polygon/component.tsx
+var g = /* @__PURE__ */ e(t(), 1), _ = p("pie-lib:graphing-solution-set:polygon"), v = (e, ...t) => u(t, 2).reduce((e, t) => {
+	if (t.length === 2) {
+		let [n, r] = t;
+		(0, g.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]), y = class extends c.Component {
+	static propTypes = {
+		className: l.string,
+		disabled: l.bool,
+		correctness: l.string,
+		points: l.arrayOf(f.PointType),
+		closed: l.bool,
+		isSolution: l.bool,
+		coordinatesOnHover: l.bool,
+		onChange: l.func.isRequired,
+		onClosePolygon: l.func.isRequired,
+		onDragStart: l.func,
+		onDragStop: l.func,
+		onClick: l.func,
+		graphProps: f.GraphPropsType.isRequired,
+		isToolActive: l.bool,
+		middle: l.object,
+		labelNode: l.object,
+		labelModeEnabled: l.bool,
+		onChangeLabelProps: l.func,
+		onChangeProps: l.func
+	};
+	static defaultProps = { points: [] };
+	dragPoint = (e, t, r) => {
+		_("[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) => {
+		_("[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(v(this.props.points, e.from, t.from, e.to, t.to));
+	};
+	dragPoly = (e, t) => {
+		_("[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;
+		_("[close] ..."), e.length >= 3 ? t() : _("[close] - nope");
+	};
+	labelChange = (e, t) => {
+		let { points: n, onChangeProps: r } = this.props, i = { ...e };
+		(!e.label || d(e.label)) && delete i.label;
+		let a = [...n];
+		a.splice(t, 1, i), r(a);
+	};
+	clickPoint = (e, t, n) => {
+		let { closed: a, disabled: o, onClick: s, isToolActive: c, labelModeEnabled: l, onChangeProps: u, onChangeLabelProps: d, points: f } = this.props;
+		if (l) {
+			if (o) return;
+			if (f && t === f.length) {
+				let { a: t, b: n } = i(f);
+				d({
+					label: "",
+					...e,
+					...r(t, n)
+				});
+			} else {
+				let n = [...f];
+				n.splice(t, 1, {
+					label: "",
+					...e
+				}), u(n);
+			}
+			this.input[t] && this.input[t].focus();
+			return;
+		}
+		if (c && !a && t === 0) {
+			this.close();
+			return;
+		}
+		s(e || n);
+	};
+	input = {};
+	render() {
+		let { closed: e, graphProps: t, onChangeLabelProps: n, points: r, middle: i, labelNode: a, labelModeEnabled: l, isSolution: u = !1 } = this.props, d = r && r.length || 0;
+		return a && i && Object.prototype.hasOwnProperty.call(i, "label") && h.createPortal(/* @__PURE__ */ m(s, {
+			inputRef: (e) => this.input[d] = e,
+			disabled: !l,
+			mark: i,
+			graphProps: t,
+			onChange: (e) => n({
+				...i,
+				label: e
+			})
+		}), a), /* @__PURE__ */ m("g", { children: /* @__PURE__ */ m(c.Fragment, { children: /* @__PURE__ */ m(o, {
+			points: r,
+			closed: e,
+			isSolution: u,
+			graphProps: t,
+			onClick: this.clickPoint.bind(this, i, d)
+		}) }) });
+	}
+}, b = y, x = class extends c.Component {
+	static propTypes = {
+		...a,
+		graphProps: f.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
+		};
+		n(t, {
+			...t,
+			middle: r
+		});
+	};
+	closePolygon = () => {
+		_("[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 } = this.props, { mark: s } = this.state;
+		return /* @__PURE__ */ m(b, {
+			...s || t,
+			coordinatesOnHover: e,
+			onChange: this.change,
+			onChangeLabelProps: this.changeLabelProps,
+			onChangeProps: this.changeProps,
+			onClosePolygon: this.closePolygon,
+			onDragStart: this.dragStart,
+			onDragStop: this.dragStop,
+			onClick: r,
+			graphProps: n,
+			isToolActive: i,
+			labelNode: a,
+			labelModeEnabled: o
+		});
+	}
+};
+//#endregion
+export { b as BaseComponent, y as RawBaseComponent, x as default, v as swap };

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

@@ -0,0 +1,19 @@
+/**
+ * @synced-from pie-lib/packages/graphing-solution-set/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 { n as addPointToArray, r as tool };