@pie-element/graphing-solution-set 6.1.2-next.1 → 6.1.2

package/dist/author/utils.js

@@ -1,474 +0,0 @@
-import { isEqual as e } from "@pie-element/shared-lodash";
-//#region src/author/utils.ts
-var t = [
-	.01,
-	.02,
-	.04,
-	.05,
-	.0625,
-	.1,
-	.125,
-	.2,
-	.25,
-	.5,
-	1,
-	2,
-	3,
-	4,
-	5,
-	8,
-	10,
-	12,
-	15,
-	20,
-	40,
-	50,
-	64,
-	100,
-	500,
-	1e3
-], n = [
-	.01,
-	.02,
-	.05,
-	.1,
-	.2,
-	.25,
-	.5,
-	1,
-	2,
-	5,
-	10,
-	20,
-	50,
-	100,
-	500,
-	1e3
-], r = {
-	.01: [
-		0,
-		.01,
-		.02,
-		.04,
-		.05,
-		.1
-	],
-	.02: [
-		0,
-		.02,
-		.04,
-		.1
-	],
-	.04: [
-		0,
-		.04,
-		.08,
-		.16,
-		.2
-	],
-	.05: [
-		0,
-		.05,
-		.1,
-		.2,
-		.25
-	],
-	.0625: [
-		0,
-		.0625,
-		.125,
-		.25,
-		.5
-	],
-	.1: [
-		0,
-		.1,
-		.2,
-		.4,
-		.5,
-		1
-	],
-	.125: [
-		0,
-		.125,
-		.25,
-		.5,
-		1
-	],
-	.2: [
-		0,
-		.2,
-		.5,
-		.1
-	],
-	.25: [
-		0,
-		.25,
-		.5,
-		1,
-		2
-	],
-	.5: [
-		0,
-		.5,
-		1,
-		2
-	],
-	1: [
-		0,
-		1,
-		2,
-		4,
-		5,
-		10
-	],
-	2: [
-		0,
-		2,
-		4,
-		8,
-		10
-	],
-	3: [
-		0,
-		3,
-		6,
-		12,
-		15
-	],
-	4: [
-		0,
-		4,
-		8,
-		16,
-		20
-	],
-	5: [
-		0,
-		5,
-		10,
-		20,
-		25
-	],
-	8: [
-		0,
-		8,
-		16,
-		32,
-		40,
-		64
-	],
-	10: [
-		0,
-		10,
-		20,
-		40,
-		50,
-		100
-	],
-	12: [
-		0,
-		12,
-		24
-	],
-	15: [
-		0,
-		15,
-		30,
-		60
-	],
-	20: [
-		0,
-		20,
-		40,
-		80,
-		100
-	],
-	40: [
-		0,
-		40,
-		80,
-		160,
-		200
-	],
-	50: [
-		0,
-		50,
-		100,
-		200,
-		250
-	],
-	64: [
-		0,
-		64,
-		128
-	],
-	100: [
-		0,
-		100,
-		200,
-		400,
-		500
-	],
-	500: [
-		0,
-		500,
-		1e3,
-		2500
-	],
-	1e3: [
-		0,
-		1e3,
-		2e3,
-		4e3,
-		5e3
-	]
-}, i = (e, r, i = !1) => {
-	let a = 10 * (e.max - e.min) / r, o = a * 10;
-	return (i ? n : t).filter((e) => e >= a && e <= o);
-}, a = (e) => r[e] || [], o = (t, n, r, o) => {
-	let s = i(t, n), c = a(t.step);
-	if (!e(r, s) && !s.includes(t.step)) {
-		let e = i(t, n, !0)[0] || 1;
-		return t.step = e, c = a(e), c.includes(t.labelStep) || (t.labelStep = e), {
-			gridValues: s,
-			labelValues: c
-		};
-	}
-	return !e(o, c) && !c.includes(t.labelStep) && (t.labelStep = t.step), {
-		gridValues: s,
-		labelValues: c
-	};
-}, s = (e) => {
-	let t = [], n = 0;
-	for (; n >= e.min && t.indexOf(n) < 0;) t.push(n), n = Math.round((n - e.step) * 1e4) / 1e4;
-	for (n = Math.round(e.step * 1e4) / 1e4; n <= e.max && t.indexOf(n) < 0;) t.push(n), n = Math.round((n + e.step) * 1e4) / 1e4;
-	return t ? t.filter((t) => t >= e.min && t <= e.max) : [];
-}, c = (e, t, n) => {
-	let r = s(e), i = s(t), a = (e, t) => r.includes(e) && i.includes(t);
-	return Object.entries(n || {}).reduce((e, [t, n]) => (e[t] = {
-		...n,
-		marks: (n.marks || []).filter((e) => {
-			if (e.type === "point") return a(e.x, e.y);
-			if (e.type === "polygon") return !e.points.find((e) => !a(e.x, e.y));
-			let t = e.from || e.root, n = e.to || e.edge;
-			return e.building ? a(t.x, t.y) : a(t.x, t.y) && a(n.x, n.y);
-		})
-	}, e), {});
-}, l = (e, t) => Number(Math.sqrt((e.x - t.x) ** 2 + (e.y - t.y) ** 2).toFixed(3)), u = (e, t) => {
-	let n = e, r = !1, i = [...t];
-	i.push(t[0]);
-	for (let e = 0; e < i.length - 1; e++) {
-		let t = i[e], a = i[e + 1];
-		if (l(t, n) + l(n, a) === l(t, a)) {
-			r = !0;
-			break;
-		}
-	}
-	return r;
-}, d = (e, t, n, r, i, a, o, s) => {
-	let c, l = (s - a) * (n - e) - (o - i) * (r - t);
-	return l === 0 ? null : (c = ((o - i) * (t - a) - (s - a) * (e - i)) / l, {
-		x: Number((e + c * (n - e)).toFixed(3)),
-		y: Number((t + c * (r - t)).toFixed(3))
-	});
-}, f = (e, t, n) => e.x > t.min && e.x < t.max && e.y > n.min && e.y < n.max, p = (e, t, n) => e.x >= t.min && e.x <= t.max && e.y >= n.min && e.y <= n.max, m = (e, t, n) => {
-	let r = [], i = [
-		[
-			t.max,
-			n.max,
-			t.max,
-			n.min
-		],
-		[
-			t.min,
-			n.max,
-			t.min,
-			n.min
-		],
-		[
-			t.min,
-			n.max,
-			t.max,
-			n.max
-		],
-		[
-			t.min,
-			n.min,
-			t.max,
-			n.min
-		]
-	];
-	for (let a = 0; a < i.length; a++) {
-		let o = d(e.from.x, e.from.y, e.to.x, e.to.y, i[a][0], i[a][1], i[a][2], i[a][3]);
-		o && p(o, t, n) && r.push(o);
-	}
-	return r;
-}, h = (e) => {
-	e.sort((e, t) => e.y - t.y);
-	let t = (e[0].y + e[e.length - 1].y) / 2;
-	e.sort((e, t) => t.x - e.x);
-	let n = {
-		x: (e[0].x + e[e.length - 1].x) / 2,
-		y: t
-	}, r;
-	e.forEach((e) => {
-		let t = Math.atan2(e.y - n.y, e.x - n.x);
-		r ? t < r && (t += Math.PI * 2) : r = t, e.angle = t;
-	}), e.sort((e, t) => e.angle - t.angle);
-	let i = e.reverse();
-	return i.unshift(i.pop()), i.map(({ angle: e, ...t }) => t);
-}, g = (e, t) => e.x * t.x + e.y * t.y, _ = (e) => Math.sqrt(e.x * e.x + e.y * e.y), v = (e, t) => {
-	let n = g(e, t), r = _(e), i = _(t);
-	return Math.acos(n / (r * i));
-}, y = (e, t, n, r) => {
-	let i = {
-		x: t.x - e.x,
-		y: t.y - e.y
-	}, a = {
-		x: n.x - e.x,
-		y: n.y - e.y
-	}, o = {
-		x: r.x - e.x,
-		y: r.y - e.y
-	}, s = v(i, o) + v(a, o);
-	return Math.abs(s - v(i, a)) < 1e-4;
-}, b = (e) => e.filter((t, n) => n === e.findIndex((e) => t.x === e.x && t.y === e.y)), x = (e) => {
-	for (let t = 0; t < e.length; t++) e[t] = e[t].filter((n, r) => r === e[t].findIndex((e) => n.x === e.x && n.y === e.y));
-	e = e.filter((e) => e.length > 2);
-	for (let t = 0; t < e.length; t++) e[t] = h(e[t]);
-	return e;
-}, S = (e, t, n) => {
-	let r = [];
-	return r.push([].concat(e)), r.push([].concat(e)), e[0].x === t.max && e[1].y === n.max || e[1].x === t.max && e[0].y === n.max ? (r[0].push({
-		x: t.max,
-		y: n.max
-	}), r[1].push({
-		x: t.min,
-		y: n.max
-	}, {
-		x: t.min,
-		y: n.min
-	}, {
-		x: t.max,
-		y: n.min
-	})) : e[0].x === t.min && e[1].y === n.max || e[1].x === t.min && e[0].y === n.max ? (r[0].push({
-		x: t.min,
-		y: n.max
-	}), r[1].push({
-		x: t.max,
-		y: n.max
-	}, {
-		x: t.max,
-		y: n.min
-	}, {
-		x: t.min,
-		y: n.min
-	})) : e[0].x === t.min && e[1].y === n.min || e[1].x === t.min && e[0].y === n.min ? (r[0].push({
-		x: t.min,
-		y: n.min
-	}), r[1].push({
-		x: t.max,
-		y: n.min
-	}, {
-		x: t.max,
-		y: n.max
-	}, {
-		x: t.min,
-		y: n.max
-	})) : e[0].x === t.max && e[1].y === n.min || e[1].x === t.max && e[0].y === n.min ? (r[0].push({
-		x: t.max,
-		y: n.min
-	}), r[1].push({
-		x: t.min,
-		y: n.min
-	}, {
-		x: t.min,
-		y: n.max
-	}, {
-		x: t.max,
-		y: n.max
-	})) : e[0].x === t.min && e[1].x === t.max || e[0].x === t.max && e[1].x === t.min ? (r[0].push({
-		x: t.min,
-		y: n.max
-	}, {
-		x: t.max,
-		y: n.max
-	}), r[1].push({
-		x: t.min,
-		y: n.min
-	}, {
-		x: t.max,
-		y: n.min
-	})) : (e[0].y === n.min && e[1].y === n.max || e[0].y === n.max && e[1].y === n.min) && (r[0].push({
-		x: t.min,
-		y: n.min
-	}, {
-		x: t.min,
-		y: n.max
-	}), r[1].push({
-		x: t.max,
-		y: n.min
-	}, {
-		x: t.max,
-		y: n.max
-	})), x(r);
-}, C = (e, t, n, r) => {
-	let i = t[0], a = t[1], o = [
-		{
-			x: n.min,
-			y: r.min
-		},
-		{
-			x: n.min,
-			y: r.max
-		},
-		{
-			x: n.max,
-			y: r.min
-		},
-		{
-			x: n.max,
-			y: r.max
-		}
-	], s = d(i.from.x, i.from.y, i.to.x, i.to.y, a.from.x, a.from.y, a.to.x, a.to.y), c = [], l = m(i, n, r);
-	l = b(l);
-	let p = m(a, n, r);
-	if (p = b(p), s && f(s, n, r)) for (let e = 0; e < l.length; e++) for (let t = 0; t < p.length; t++) {
-		let n = [], r = [];
-		n.push(s), n.push(l[e]), n.push(p[t]);
-		for (let i = 0; i < o.length; i++) y(s, l[e], p[t], o[i]) ? n.push(o[i]) : r.push(o[i]);
-		o = r, c.push(n);
-	}
-	else {
-		let e = S(l, n, r), t = S(p, n, r);
-		for (let t = 0; t < e.length; t++) u(p[0], e[t]) && u(p[1], e[t]) || c.push(e[t]);
-		for (let e = 0; e < t.length; e++) u(l[0], t[e]) && u(l[1], t[e]) || c.push(t[e]);
-		for (let e = 0; e < c.length; e++) o = o.filter(function(t) {
-			return !c[e].some(function(e) {
-				return t.x === e.x && t.y === e.y;
-			});
-		});
-		let i = o.concat(l, p);
-		c.push(i);
-	}
-	return x(c);
-}, w = (e, t, n, r) => (e.numberOfLines === 1 ? e.sections = S(m(t[0], n, r), n, r) : e.sections = C(e, t, n, r), e), T = (e, t) => {
-	let n = t.length, r = e.x, i = e.y, a = !1, o = t[0], s;
-	for (let e = 1; e <= n; e++) {
-		if (s = t[e % n], i > Math.min(o.y, s.y) && i <= Math.max(o.y, s.y) && r <= Math.max(o.x, s.x)) {
-			let e = (i - o.y) * (s.x - o.x) / (s.y - o.y) + o.x;
-			(o.x === s.x || r <= e) && (a = !a);
-		}
-		o = s;
-	}
-	return a;
-}, E = (e, t) => {
-	if (t.length === 0) return !1;
-	if (e.numberOfLines === 1) {
-		if (t.length === 1) return !t[0].building;
-	} else if (t.length !== 2) return !1;
-	else return !t[1].building;
-};
-//#endregion
-export { o as applyConstraints, E as checkIfLinesAreAdded, c as filterPlotableMarks, w as findSectionsInSolutionSet, i as getGridValues, a as getLabelValues, T as pointInsidePolygon };