@pie-element/graphing-solution-set 6.1.1-next.11 → 6.1.2-next.0

package/dist/author/index.js

@@ -0,0 +1,87 @@
+import e from "./configure.js";
+import t from "./defaults.js";
+import n from "react";
+import { createRoot as r } from "react-dom/client";
+import { renderMath as i } from "@pie-element/shared-math-rendering-mathjax";
+import a from "debug";
+import { DeleteImageEvent as o, DeleteSoundEvent as s, InsertImageEvent as c, InsertSoundEvent as l, ModelUpdatedEvent as u } from "@pie-element/shared-configure-events";
+//#region src/author/index.ts
+var d = a("pie-elements:graphing-solution-set:configure"), f = (e) => Object.keys(e || {}).sort().reduce((t, n) => (n !== "correctAnswer" && (t[n] = e[n]), t), {}), p = class a extends HTMLElement {
+	static createDefaultModel = (e = {}) => {
+		let n = {
+			...t.model,
+			...e
+		}, { answers: r = {}, domain: i = {}, graph: a = {}, range: o = {}, standardGrid: s } = n;
+		return {
+			...n,
+			answers: r && r.correctAnswer && {
+				correctAnswer: r.correctAnswer,
+				...f(r)
+			} || r,
+			range: s && {
+				...o,
+				min: i.min,
+				max: i.max,
+				step: i.step,
+				labelStep: i.labelStep
+			} || o,
+			graph: s && {
+				...a,
+				height: a.width
+			} || a
+		};
+	};
+	constructor() {
+		super(), this._root = null, this._model = a.createDefaultModel(), this._configuration = t.configuration;
+	}
+	set model(e) {
+		this._model = a.createDefaultModel(e), this._render();
+	}
+	set configuration(e) {
+		this._configuration = e, e.language?.enabled ? e.languageChoices?.options?.length && (this._model.language = e.languageChoices.options[0].value) : e.language.settings ? this._model.language && (this._configuration.language.enabled = !0) : delete this._model.language, this._render();
+	}
+	onModelChanged = (e) => {
+		this._model = e, this._render(), d("[onModelChanged]: ", this._model), this.dispatchEvent(new u(this._model));
+	};
+	onConfigurationChanged = (e) => {
+		this._configuration = e, this._render();
+	};
+	insertImage = (e) => {
+		this.dispatchEvent(new c(e));
+	};
+	onDeleteImage = (e, t) => {
+		this.dispatchEvent(new o(e, t));
+	};
+	insertSound(e) {
+		this.dispatchEvent(new l(e));
+	}
+	onDeleteSound(e, t) {
+		this.dispatchEvent(new s(e, t));
+	}
+	_render() {
+		if (this._model) {
+			let t = n.createElement(e, {
+				onModelChanged: this.onModelChanged,
+				onConfigurationChanged: this.onConfigurationChanged,
+				model: this._model,
+				configuration: this._configuration,
+				imageSupport: {
+					add: this.insertImage,
+					delete: this.onDeleteImage
+				},
+				uploadSoundSupport: {
+					add: this.insertSound.bind(this),
+					delete: this.onDeleteSound.bind(this)
+				}
+			});
+			this._root ||= r(this), this._root.render(t), queueMicrotask(() => {
+				i(this);
+			});
+		}
+	}
+	disconnectedCallback() {
+		this._root && this._root.unmount();
+	}
+};
+//#endregion
+export { p as default };

package/dist/author/utils.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @synced-from pie-elements/packages/graphing-solution-set/configure/src/utils.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 VALID_LABEL_VALUES: {
+    0.01: number[];
+    0.02: number[];
+    0.04: number[];
+    0.05: number[];
+    0.0625: number[];
+    0.1: number[];
+    0.125: number[];
+    0.2: number[];
+    0.25: number[];
+    0.5: number[];
+    1: number[];
+    2: number[];
+    3: number[];
+    4: number[];
+    5: number[];
+    8: number[];
+    10: number[];
+    12: number[];
+    15: number[];
+    20: number[];
+    40: number[];
+    50: number[];
+    64: number[];
+    100: number[];
+    500: number[];
+    1000: number[];
+};
+export declare const getGridValues: (axis: any, size: any, prefferedValues?: boolean) => number[];
+export declare const getLabelValues: (value: any) => any;
+export declare const applyConstraints: (axis: any, size: any, oldGridValues: any, oldLabelValues: any) => {
+    gridValues: number[];
+    labelValues: any;
+};
+export declare const filterPlotableMarks: (domain: any, range: any, answers: any) => {};
+export declare const findSectionsInSolutionSet: (gssLineData: any, answers: any, domain: any, range: any) => any;
+export declare const pointInsidePolygon: (point: any, polygon: any) => boolean;
+export declare const checkIfLinesAreAdded: (gssLineData: any, answer: any) => boolean | undefined;

package/dist/author/utils.js

@@ -0,0 +1,474 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isEqual.js";
+//#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 };