@pie-element/graphing 11.0.4-next.20261011174919 → 11.0.4

package/dist/controller/utils.js

@@ -1,111 +1,98 @@
 import { differenceWith as e, isEqual as t, uniq as n, uniqWith as r } from "@pie-element/shared-lodash";
 import { getAmplitudeAndFreq as i, pointsToABC as a, pointsToABForExponential as o, pointsToAForAbsolute as s } from "@pie-lib/graphing-utils";
 //#region src/controller/utils.ts
-var c = (e, n) => (e = { ...e }, n = { ...n }, t(e.x, n.x) && t(e.y, n.y)), l = (e, n) => {
+var c = (e) => ({ ...e }), l = (e, n) => (e = { ...e }, n = { ...n }, t(e.x, n.x) && t(e.y, n.y)), u = (e, n) => {
 	let r = !0;
 	return e = { ...e }, n = { ...n }, (e.label || n.label) && (r = t(e.label, n.label)), t(e.x, n.x) && t(e.y, n.y) && r;
-}, u = (e, n) => t(e.from, n.from) && t(e.to, n.to) || t(e.to, n.from) && t(e.from, n.to), d = (e, n) => t(e.from, n.from) && t(e.to, n.to), f = (e) => Object.keys(e || {}).sort().reduce((t, n) => (n !== "correctAnswer" && (t[n] = e[n]), t), {}), p = (e) => {
-	e = {
-		...e,
-		to: { ...e.to },
-		from: { ...e.from }
-	};
-	let t = e.from.x, n = e.from.y, r = e.to.x, i = e.to.y;
+}, d = (e, n) => t(e.from, n.from) && t(e.to, n.to) || t(e.to, n.from) && t(e.from, n.to), f = (e, n) => t(e.from, n.from) && t(e.to, n.to), p = (e) => Object.keys(e || {}).sort().reduce((t, n) => (e && n !== "correctAnswer" && (t[n] = e[n]), t), {}), m = (e) => {
+	let t = c(e.from), n = c(e.to), r = t.x, i = t.y, a = n.x, o = n.y;
 	return {
-		a: i - n,
-		b: t - r,
-		c: r * n - t * i
+		a: o - i,
+		b: r - a,
+		c: a * i - r * o
 	};
-}, m = (e) => Math.round(e * 1e4) / 1e4, h = (e, t) => {
-	let { a: r, b: i, c: a } = p(e), { a: o, b: s, c } = p(t), l = [];
-	if (o !== 0) l.push(m(r / o));
+}, h = (e) => Math.round(e * 1e4) / 1e4, g = (e, t) => {
+	let { a: r, b: i, c: a } = m(e), { a: o, b: s, c } = m(t), l = [];
+	if (o !== 0) l.push(h(r / o));
 	else if (r !== o) return !1;
-	if (s !== 0) l.push(m(i / s));
+	if (s !== 0) l.push(h(i / s));
 	else if (i !== s) return !1;
-	if (c !== 0) l.push(m(a / c));
+	if (c !== 0) l.push(h(a / c));
 	else if (a !== c) return !1;
 	return n(l).length === 1;
-}, g = (e, t) => {
-	e = {
-		...e,
-		to: { ...e.to },
-		from: { ...e.from }
-	}, t = {
-		...t,
-		to: { ...t.to },
-		from: { ...t.from }
+}, _ = (e, t) => {
+	let n = {
+		from: c(e.from),
+		to: c(e.to)
+	}, r = {
+		from: c(t.from),
+		to: c(t.to)
+	}, i = (n.to.y - n.from.y) / (n.to.x - n.from.x), a = (r.to.y - r.from.y) / (r.to.x - r.from.x), o = Math.atan2(n.to.y - n.from.y, n.to.x - n.from.x) * 180 / Math.PI, s = Math.atan2(r.to.y - r.from.y, r.to.x - r.from.x) * 180 / Math.PI;
+	return i === a && n.from.x === r.from.x && n.from.y === r.from.y && o === s;
+}, v = (e) => {
+	let t = e || [];
+	return t.map((e, n) => ({
+		from: e,
+		to: t[(n + 1) % t.length]
+	}));
+}, y = (e) => (e ||= [], r(e, (e, t) => d(e, t))), b = (e) => (e ||= [], e.filter((e) => !t(e.from, e.to))), x = (t, n) => {
+	let { points: r } = t, { points: i } = n, a = v(r), o = v(i), s = y(b(a)), c = y(b(o)), l = e(s, c, d), u = e(c, s, d);
+	return (!l || !l.length) && (!u || !u.length);
+}, S = (e, n) => {
+	let r = {
+		root: c(e.root),
+		edge: c(e.edge)
+	}, i = {
+		root: c(n.root),
+		edge: c(n.edge)
 	};
-	let n = (e.to.y - e.from.y) / (e.to.x - e.from.x), r = (t.to.y - t.from.y) / (t.to.x - t.from.x), i = Math.atan2(e.to.y - e.from.y, e.to.x - e.from.x) * 180 / Math.PI, a = Math.atan2(t.to.y - t.from.y, t.to.x - t.from.x) * 180 / Math.PI;
-	return n === r && e.from.x === t.from.x && e.from.y === t.from.y && i === a;
-}, _ = (e) => (e || []).map((t, n) => ({
-	from: t,
-	to: e[(n + 1) % e.length]
-})), v = (e) => (e ||= [], r(e, (e, t) => u(e, t))), y = (e) => (e ||= [], e.filter((e) => !t(e.from, e.to))), b = (t, n) => {
-	let { points: r } = t, { points: i } = n, a = _(r), o = _(i), s = v(y(a)), c = v(y(o)), l = e(s, c, u), d = e(c, s, u);
-	return (!l || !l.length) && (!d || !d.length);
-}, x = (e, n) => {
-	if (e = {
-		...e,
-		root: { ...e.root },
-		edge: { ...e.edge }
-	}, n = {
-		...n,
-		root: { ...n.root },
-		edge: { ...n.edge }
-	}, t(n.edge, e.edge) && t(n.root, e.root)) return !0;
-	let r = Math.sqrt((e.edge.x - e.root.x) ** 2 + (e.edge.y - e.root.y) ** 2), i = Math.sqrt((n.edge.x - n.root.x) ** 2 + (n.edge.y - n.root.y) ** 2);
-	return t(n.root, e.root) && t(r, i);
-}, S = (e, t) => {
-	let n = ({ root: e, edge: t }) => {
-		e = { ...e }, t = { ...t };
-		let { amplitude: n, freq: r } = i(e, t), a = Math.abs(e.y - t.y) * 2, o = Math.abs(e.x - t.x) * 2, s = t.x, c = t.y;
-		for (; s < 0 && o !== 0;) s += o, c = c < e.y ? c + a : c - a;
-		for (; s - o > 0 && o !== 0;) s -= o, c = c < e.y ? c + a : c - a;
+	if (t(i.edge, r.edge) && t(i.root, r.root)) return !0;
+	let a = Math.sqrt((r.edge.x - r.root.x) ** 2 + (r.edge.y - r.root.y) ** 2), o = Math.sqrt((i.edge.x - i.root.x) ** 2 + (i.edge.y - i.root.y) ** 2);
+	return t(i.root, r.root) && t(a, o);
+}, C = (e, t) => {
+	let n = (e) => {
+		let t = c(e.root), n = c(e.edge), { amplitude: r, freq: a } = i(t, n), o = Math.abs(t.y - n.y) * 2, s = Math.abs(t.x - n.x) * 2, l = n.x, u = n.y;
+		for (; l < 0 && s !== 0;) l += s, u = u < t.y ? u + o : u - o;
+		for (; l - s > 0 && s !== 0;) l -= s, u = u < t.y ? u + o : u - o;
 		return {
-			amplitude: m(n),
-			freq: m(r),
-			min: m(t.y < e.y ? t.y : t.y - a),
-			max: m(t.y < e.y ? t.y + a : t.y),
-			edgeAboveZeroX: m(s),
-			edgeAboveZeroY: m(c)
+			amplitude: h(r),
+			freq: h(a),
+			min: h(n.y < t.y ? n.y : n.y - o),
+			max: h(n.y < t.y ? n.y + o : n.y),
+			edgeAboveZeroX: h(l),
+			edgeAboveZeroY: h(u)
 		};
-	}, r = n(e), a = n(t), { amplitude: o, freq: s, min: c, max: l, edgeAboveZeroX: u, edgeAboveZeroY: d } = r, { amplitude: f, freq: p, min: h, max: g, edgeAboveZeroX: _, edgeAboveZeroY: v } = a;
-	return Math.abs(o) === Math.abs(f) && Math.abs(s) === Math.abs(p) && c === h && l === g && u === _ && d === v;
-}, C = (e, t) => {
-	let { edge: n } = e, { edge: r } = t, { root: i } = e, { root: o } = t;
-	i = { ...i }, o = { ...o };
-	let s = n || { ...i }, c = r || { ...o }, l = {
+	}, r = n(e), a = n(t), { amplitude: o, freq: s, min: l, max: u, edgeAboveZeroX: d, edgeAboveZeroY: f } = r, { amplitude: p, freq: m, min: g, max: _, edgeAboveZeroX: v, edgeAboveZeroY: y } = a;
+	return Math.abs(o) === Math.abs(p) && Math.abs(s) === Math.abs(m) && l === g && u === _ && d === v && f === y;
+}, w = (e, t) => {
+	let { edge: n } = e, { edge: r } = t, i = c(e.root), o = c(t.root), s = n || { ...i }, l = r || { ...o }, u = {
 		x: i.x - (s.x - i.x),
 		y: s.y
-	}, u = {
-		x: o.x - (c.x - o.x),
-		y: c.y
+	}, d = {
+		x: o.x - (l.x - o.x),
+		y: l.y
 	};
 	if (!n || !r) return !1;
-	let { a: d, b: f, c: p } = a(i, n, l), { a: m, b: h, c: g } = a(o, r, u), _ = (e) => Math.round(e * 1e4) / 1e4;
-	return _(d) === _(m) && _(f) === _(h) && _(p) === _(g);
-}, w = (e, n) => {
-	let { edge: r } = e, { edge: i } = n, { root: a } = e, { root: o } = n;
-	a = { ...a }, o = { ...o };
-	let c = r || { ...a }, l = i || { ...o }, u = s(a, c), d = s(o, l);
-	return t(o, a) && t(d, u);
+	let { a: f, b: p, c: m } = a(i, n, u), { a: h, b: g, c: _ } = a(o, r, d), v = (e) => Math.round(e * 1e4) / 1e4;
+	return v(f) === v(h) && v(p) === v(g) && v(m) === v(_);
 }, T = (e, n) => {
-	let { edge: r } = e, { edge: i } = n, { root: a } = e, { root: s } = n;
-	a = { ...a }, s = { ...s };
-	let c = r || { ...a }, l = i || { ...s }, { a: u, b: d } = o(a, c), { a: f, b: p } = o(s, l);
-	return t(f, u) && t(p, d);
-}, E = {
-	circle: (e, t) => x(e, t),
-	line: (e, t) => h(e, t),
-	parabola: (e, t) => C(e, t),
-	absolute: (e, t) => w(e, t),
-	exponential: (e, t) => T(e, t),
-	point: (e, t) => c(e, t),
-	polygon: (e, t) => b(e, t),
-	ray: (e, t) => g(e, t),
-	segment: (e, t) => u(e, t),
-	sine: (e, t) => S(e, t),
-	vector: (e, t) => d(e, t)
+	let { edge: r } = e, { edge: i } = n, a = c(e.root), o = c(n.root), l = r || { ...a }, u = i || { ...o }, d = s(a, l), f = s(o, u);
+	return t(o, a) && t(f, d);
+}, E = (e, n) => {
+	let { edge: r } = e, { edge: i } = n, a = c(e.root), s = c(n.root), l = r || { ...a }, u = i || { ...s }, { a: d, b: f } = o(a, l), { a: p, b: m } = o(s, u);
+	return t(p, d) && t(m, f);
+}, D = {
+	circle: (e, t) => S(e, t),
+	line: (e, t) => g(e, t),
+	parabola: (e, t) => w(e, t),
+	absolute: (e, t) => T(e, t),
+	exponential: (e, t) => E(e, t),
+	point: (e, t) => l(e, t),
+	polygon: (e, t) => x(e, t),
+	ray: (e, t) => _(e, t),
+	segment: (e, t) => d(e, t),
+	sine: (e, t) => C(e, t),
+	vector: (e, t) => f(e, t)
 };
 //#endregion
-export { _ as constructSegmentsFromPoints, w as equalAbsolute, x as equalCircle, T as equalExponential, h as equalLine, E as equalMarks, C as equalParabola, c as equalPoint, l as equalPointWithLabel, b as equalPolygon, g as equalRay, u as equalSegment, S as equalSine, d as equalVector, v as removeDuplicateSegments, y as removeInvalidSegments, f as sortedAnswers };
+export { v as constructSegmentsFromPoints, T as equalAbsolute, S as equalCircle, E as equalExponential, g as equalLine, D as equalMarks, w as equalParabola, l as equalPoint, u as equalPointWithLabel, x as equalPolygon, _ as equalRay, d as equalSegment, C as equalSine, f as equalVector, y as removeDuplicateSegments, b as removeInvalidSegments, p as sortedAnswers };

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { default } from './delivery/index.js';
+export type * from './types.js';