@mathscan/geometry-engine 0.1.0 → 0.1.1

package/dist/goals-BlSeniyt.js

@@ -0,0 +1,563 @@
+import { $ as e, A as t, Ct as n, H as r, J as i, K as a, L as o, M as s, Q as c, St as l, Tt as u, V as d, X as f, Y as p, Z as m, f as h, p as g, q as _, w as ee, wt as v, z as y } from "./geometryState.schema-CKFPlX8j.js";
+//#region src/geometry/goalCandidate.ts
+function b(e) {
+	return e.definition.kind === "point";
+}
+//#endregion
+//#region src/geometry/evaluateGraph.ts
+var x = Object.freeze([]);
+function te(e) {
+	let t = e[0] && o(e[0]), n = e[1] && o(e[1]);
+	return !t || !n ? "degenerate" : i(c(t), c(n)).length > 0 ? "out-of-domain" : "degenerate";
+}
+function S(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(), r = [], i = [];
+	function a(t) {
+		let n = e.pathOf?.(t);
+		return n === void 0 ? {} : { path: n };
+	}
+	function o(s) {
+		let c = t.get(s);
+		if (c) return c;
+		if (n.has(s)) return null;
+		let l = e.definitionOf(s);
+		if (!l) return null;
+		let u = i.indexOf(s);
+		if (u !== -1) return r.push({
+			entityId: s,
+			reason: "cycle",
+			cycle: i.slice(u),
+			...a(s)
+		}), n.add(s), null;
+		let f = y(l), p = x, m = !0;
+		if (f.length > 0) {
+			i.push(s);
+			let e = [];
+			for (let t of f) {
+				let n = o(t);
+				n ? e.push(n) : m = !1;
+			}
+			i.pop(), p = e;
+		}
+		if (!m) {
+			for (let t of f) e.definitionOf(t) === void 0 && r.push({
+				entityId: s,
+				reason: "missing-parent",
+				parentId: t,
+				...a(s)
+			});
+			return n.add(s), null;
+		}
+		let h = d(l, p);
+		return h ? (t.set(s, h), h) : (r.push({
+			entityId: s,
+			reason: te(p),
+			...a(s)
+		}), n.add(s), null);
+	}
+	return {
+		resolve: o,
+		resolved: t,
+		issues: r
+	};
+}
+//#endregion
+//#region src/state/geometryContext.ts
+var C = { role: "implicit" }, w = { role: "explicit" }, T = Object.freeze([]), E = class {
+	constructor(e, t, n, r, i, a, o, s, c, l, u) {
+		this.exercise = e, this.geometry = t, this.pinned = n, this.draggable = r, this.attemptPoints = i, this.objects = a, this.points = o, this.declaresPoint = s, this.definitionSource = c, this.resolveEntity = l, this.issues = u, this.dependents = null, this.pointIdList = null, this.entityIdList = null;
+	}
+	get entityIds() {
+		return this.entityIdList ?? (this.entityIdList = Object.freeze([...this.pointIds(), ...this.objects.keys()])), this.entityIdList;
+	}
+	definitionOf(e) {
+		return this.definitionSource(e);
+	}
+	resolvedOf(e) {
+		return this.resolveEntity(e) ?? void 0;
+	}
+	shapeOf(e) {
+		let t = this.resolvedOf(e);
+		return t ? r(t) : void 0;
+	}
+	measuredOf(e) {
+		if (!this.objects.has(e)) return null;
+		let t = this.resolveEntity(e);
+		return t ? o(t) : null;
+	}
+	kindOf(e) {
+		return this.declaresPoint(e) ? "point" : this.objects.get(e)?.kind;
+	}
+	presentationOf(e) {
+		return Object.prototype.hasOwnProperty.call(this.exercise.entities, e) ? s(this.exercise.presentation, e) ?? w : s(this.geometry.presentation, e) ?? C;
+	}
+	isGiven(e) {
+		return Object.prototype.hasOwnProperty.call(this.exercise.entities, e);
+	}
+	parentsOf(e) {
+		let t = this.definitionOf(e);
+		if (!t) return T;
+		let n = y(t);
+		return n.length === 0 ? T : [...n];
+	}
+	dependentsOf(e) {
+		return this.dependentsIndex().get(e) ?? T;
+	}
+	removalClosureOf(e) {
+		if (!this.declaresPoint(e) && !this.objects.has(e)) return T;
+		let t = this.dependentsIndex(), n = [e], r = /* @__PURE__ */ new Set([e]);
+		for (let e = 0; e < n.length; e += 1) for (let i of t.get(n[e]) ?? T) r.has(i) || (r.add(i), n.push(i));
+		return n;
+	}
+	allowsObjectType(e) {
+		return this.exercise.allowedObjects.includes(e);
+	}
+	allowsTool(e) {
+		return this.exercise.tools.includes(e);
+	}
+	isBuiltFrom(e, t) {
+		return e === this.exercise && t === this.geometry;
+	}
+	pointIds() {
+		if (this.pointIdList) return this.pointIdList;
+		let e = [...this.pinned.keys(), ...this.draggable.keys()], t = new Set(e);
+		for (let n of this.attemptPoints.keys()) t.has(n) || e.push(n);
+		return this.pointIdList = e, e;
+	}
+	dependentsIndex() {
+		if (this.dependents) return this.dependents;
+		let e = /* @__PURE__ */ new Map(), t = (t, n) => {
+			let r = e.get(t);
+			r ? r.push(n) : e.set(t, [n]);
+		};
+		for (let e of this.entityIds) for (let n of this.parentsOf(e)) t(n, e);
+		return this.dependents = e, e;
+	}
+};
+function D(e, n) {
+	let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), c = [];
+	for (let n in e.entities) {
+		let a = s(e.entities, n);
+		a && (a.kind === "point" ? t(e, n) ? i.set(n, a) : r.set(n, a) : o.set(n, a));
+	}
+	for (let t in n.entities) {
+		let r = s(n.entities, t);
+		if (!r) continue;
+		let i = s(e.entities, t);
+		if (i) {
+			let n = ee(e, t, i, r);
+			if (n === "ignored") continue;
+			if (n === "collision") {
+				c.push({
+					entityId: t,
+					reason: "duplicate-id",
+					path: `geometry.entities.${t}`
+				});
+				continue;
+			}
+		}
+		r.kind === "point" ? a.set(t, r) : o.set(t, r);
+	}
+	function l(e) {
+		return r.get(e) || (a.get(e) ?? i.get(e));
+	}
+	function u(e) {
+		return r.has(e) || a.has(e) || i.has(e);
+	}
+	function d(e) {
+		return l(e) ?? o.get(e);
+	}
+	function f(t) {
+		let n = Object.prototype.hasOwnProperty.call(e.entities, t);
+		return (a.has(t) ? !r.has(t) : o.has(t) && !n) ? `geometry.entities.${t}` : n ? `exercise.entities.${t}` : void 0;
+	}
+	let p = S({
+		definitionOf: d,
+		pathOf: f
+	});
+	function m(e) {
+		return u(e) || o.has(e);
+	}
+	for (let [e, t] of o) {
+		let n = f(e);
+		if (n !== void 0) for (let r of y(t)) m(r) || c.push({
+			entityId: e,
+			reason: "missing-parent",
+			parentId: r,
+			path: n
+		});
+	}
+	for (let e of r.keys()) p.resolve(e);
+	for (let e of i.keys()) p.resolve(e);
+	for (let e of a.keys()) p.resolve(e);
+	let h = /* @__PURE__ */ new Map();
+	for (let [e, t] of p.resolved) t.kind === "point" && h.set(e, t.at);
+	return c.push(...p.issues), new E(e, n, r, i, a, o, h, u, d, p.resolve, Object.freeze(c));
+}
+//#endregion
+//#region src/state/resolvePoints.ts
+function O(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let [t, r] of Object.entries(e.entities)) r.kind !== "point" && n.set(t, {
+		id: t,
+		definition: r
+	});
+	for (let [e, r] of Object.entries(t.entities)) r.kind !== "point" && !n.has(e) && n.set(e, {
+		id: e,
+		definition: r
+	});
+	return n;
+}
+function k(e, t) {
+	return D(e, t).points;
+}
+function A(e) {
+	return j(e).points;
+}
+function j(e) {
+	return D(e, ne);
+}
+var ne = {
+	schemaVersion: 2,
+	entities: {},
+	presentation: {},
+	answerEntityIds: []
+};
+//#endregion
+//#region src/validation/goals/goalContext.ts
+function M(e, t) {
+	let n = e.get(t);
+	if (!n) throw Error(`Unknown point "${t}" during validation.`);
+	return n;
+}
+function N(e, t) {
+	return [M(e, t[0]), M(e, t[1])];
+}
+function P(e, t) {
+	let n = s(e.exercise.entities, t);
+	if (!n || !g(n.kind)) throw Error(`Unknown reference object "${t}" during validation.`);
+	let [r, i] = y(n);
+	if (r === void 0 || i === void 0) throw Error(`Reference object "${t}" has no endpoint pair.`);
+	return N(e.points, [r, i]);
+}
+function F(e, t) {
+	return !b(e) && e.definition.kind === t;
+}
+function I(e, t) {
+	return g(t) && F(e, t);
+}
+function L(e) {
+	let t = y(e.definition), [n, r] = t;
+	if (t.length !== 2 || n === void 0 || r === void 0) throw Error(`candidateEndpoints: ${e.definition.kind} is not defined by two points.`);
+	return [n, r];
+}
+//#endregion
+//#region src/validation/goals/angleCriterion.ts
+function re(e, t) {
+	let n = e * 360;
+	return t === "undirected" ? Math.min(n, 360 - n) : n;
+}
+function R(t, n, r) {
+	let i = re(t, n);
+	return r.kind === "degrees" ? l(a(i, r.targetDegrees), r.toleranceDegrees) : e(i) === r.angleType;
+}
+function z(e, [t, n, r]) {
+	let i = M(e, n), a = _(i, M(e, t)), o = _(i, M(e, r));
+	return a === null || o === null ? null : {
+		vertex: i,
+		startTurn: a,
+		sweepTurn: m(a, o)
+	};
+}
+//#endregion
+//#region src/validation/goals/previewGeometry.ts
+function B(e, t, n) {
+	return {
+		x: e.x + Math.cos(t) * n,
+		y: e.y + Math.sin(t) * n
+	};
+}
+function V(e, t) {
+	let [n, r, i, a] = t;
+	if (e.x >= n && e.x <= i && e.y >= r && e.y <= a) return Math.min(e.x - n, i - e.x, e.y - r, a - e.y);
+	let o = Math.max(n, Math.min(i, e.x)), s = Math.max(r, Math.min(a, e.y));
+	return -Math.hypot(e.x - o, e.y - s);
+}
+function H(e, t) {
+	let n = e[0];
+	if (!n) throw Error("mostVisibleInViewport requires at least one candidate.");
+	let r = V(n, t);
+	for (let i of e.slice(1)) {
+		let e = V(i, t);
+		e > r && (n = i, r = e);
+	}
+	return n;
+}
+function U(e, t) {
+	let [n, r, i, a] = e, o = Math.max(.5, Math.min(i - n, a - r) * .28);
+	return Math.min(t || 1, o);
+}
+function W(e, t, n) {
+	return e === "line" ? {
+		type: "line",
+		through: [t, n]
+	} : {
+		type: "segment",
+		from: t,
+		to: n
+	};
+}
+//#endregion
+//#region src/validation/goals/angleBisector.ts
+function G(e, t) {
+	let n = s(e.exercise.entities, t);
+	if (n?.kind !== "angle") throw Error(`Unknown reference angle "${t}" during validation.`);
+	return n.parents;
+}
+function K(e, t, n) {
+	let r = z(e.points, G(e, t.referenceAngleId));
+	if (!r) return null;
+	let i = r.startTurn + r.sweepTurn / 2;
+	return [r.vertex, B(r.vertex, 2 * Math.PI * i, n)];
+}
+var q = {
+	...h.angleBisector,
+	subject: "candidates",
+	accepts(e, t) {
+		return I(e, t.objectType);
+	},
+	satisfies(e, t, n) {
+		let r = G(n, t.referenceAngleId)[1], i = L(e);
+		if (!i.includes(r)) return !1;
+		let a = K(n, t, 1);
+		if (!a) return !1;
+		let [o, s] = N(n.points, i);
+		return l(p(a[0], a[1], o, s), t.toleranceDegrees);
+	},
+	isRelevantAttempt(e, t, n) {
+		let r = G(n, t.referenceAngleId)[1];
+		return y(e.definition).includes(r);
+	},
+	buildRevealedAnswer(e, t) {
+		let [n, r] = G(t, e.referenceAngleId), i = v(M(t.points, r), M(t.points, n)), a = K(t, e, U(t.exercise.viewport, i));
+		return a && W(e.objectType, a[0], a[1]);
+	}
+}, J = {
+	acute: 45,
+	right: 90,
+	obtuse: 135,
+	straight: 180,
+	reflex: 270
+}, Y = {
+	...h.angleMeasure,
+	subject: "candidates",
+	accepts(e) {
+		return e.definition.kind === "angle";
+	},
+	satisfies(e, t, n) {
+		if (e.definition.parents[1] !== t.vertexPointId) return !1;
+		let r = z(n.points, e.definition.parents);
+		return r !== null && R(r.sweepTurn, t.interpretation, t.criterion);
+	},
+	isRelevantAttempt(e, t) {
+		return e.definition.parents[1] === t.vertexPointId;
+	},
+	buildRevealedAnswer(e, t) {
+		let n = M(t.points, e.vertexPointId), { criterion: r } = e, i = (r.kind === "degrees" ? r.targetDegrees : J[r.angleType]) * Math.PI / 180, { viewport: a } = t.exercise, o = U(a, Infinity), s = i === 0 ? o / 2 : o, c = (e) => [B(n, e, o), B(n, e + i, s)], l = (e) => Math.min(...e.map((e) => V(e, a))), u = c(0);
+		for (let e = 1; e < 8; e++) {
+			let t = c(e * Math.PI / 4);
+			l(t) > l(u) && (u = t);
+		}
+		return {
+			type: "angle",
+			vertex: n,
+			arms: u
+		};
+	}
+}, ie = {
+	...h.create,
+	subject: "candidates",
+	accepts(e, t) {
+		return e.definition.kind === t.objectType;
+	},
+	satisfies() {
+		return !0;
+	},
+	isRelevantAttempt() {
+		return !0;
+	},
+	buildRevealedAnswer() {
+		return null;
+	}
+}, ae = {
+	...h.givenAngle,
+	subject: "figure",
+	satisfiedByFigure(e, t) {
+		let n = t.scene.resolvedOf(e.angleId);
+		if (n?.kind === "angle") return R(n.sweepTurn, e.interpretation, e.criterion);
+	},
+	judgedEntityIds: (e) => [e.angleId]
+};
+//#endregion
+//#region src/validation/goals/midpoint.ts
+function X(e, t) {
+	let [n, r] = P(t, e.referenceObjectId);
+	return u(n, r);
+}
+var oe = {
+	...h.midpoint,
+	subject: "candidates",
+	accepts(e) {
+		return b(e);
+	},
+	satisfies(e, t, n) {
+		let r = M(n.points, e.id), i = v(r, X(t, n));
+		return l(i, t.toleranceUnits);
+	},
+	isRelevantAttempt() {
+		return !0;
+	},
+	buildRevealedAnswer(e, t) {
+		return {
+			type: "point",
+			at: X(e, t)
+		};
+	}
+}, se = {
+	...h.parallel,
+	subject: "candidates",
+	accepts(e, t) {
+		return I(e, t.objectType);
+	},
+	satisfies(e, t, n) {
+		let r = L(e);
+		if (!r.includes(t.throughPointId)) return !1;
+		let [i, a] = P(n, t.referenceObjectId), [o, s] = N(n.points, r), c = p(i, a, o, s);
+		return l(c, t.toleranceDegrees);
+	},
+	isRelevantAttempt(e, t) {
+		return y(e.definition).includes(t.throughPointId);
+	},
+	buildRevealedAnswer(e, t) {
+		let [n, r] = P(t, e.referenceObjectId), i = M(t.points, e.throughPointId), a = Math.atan2(r.y - n.y, r.x - n.x), o = U(t.exercise.viewport, v(n, r)), s = H([B(i, a, o), B(i, a + Math.PI, o)], t.exercise.viewport);
+		return W(e.objectType, i, s);
+	}
+}, ce = {
+	...h.perpendicular,
+	subject: "candidates",
+	accepts(e, t) {
+		return I(e, t.objectType);
+	},
+	satisfies(e, t, r) {
+		let i = L(e);
+		if (!i.includes(t.throughPointId)) return !1;
+		let [a, o] = P(r, t.referenceObjectId), [s, c] = N(r.points, i), l = p(a, o, s, c);
+		return n(l, 90, t.toleranceDegrees);
+	},
+	isRelevantAttempt(e, t) {
+		return y(e.definition).includes(t.throughPointId);
+	},
+	buildRevealedAnswer(e, t) {
+		let [n, r] = P(t, e.referenceObjectId), i = M(t.points, e.throughPointId), a = Math.atan2(r.y - n.y, r.x - n.x), o = U(t.exercise.viewport, v(n, r)), s = H([B(i, a + Math.PI / 2, o), B(i, a - Math.PI / 2, o)], t.exercise.viewport);
+		return W(e.objectType, i, s);
+	}
+}, le = {
+	...h.segmentLength,
+	subject: "candidates",
+	accepts(e, t) {
+		return F(e, t.objectType);
+	},
+	satisfies(e, t, r) {
+		let [i, a] = N(r.points, L(e));
+		return n(v(i, a), t.targetLength, t.toleranceUnits);
+	},
+	isRelevantAttempt() {
+		return !0;
+	},
+	buildRevealedAnswer(e, t) {
+		let [n, r, i, a] = t.exercise.viewport, o = (n + i) / 2, s = (r + a) / 2;
+		return {
+			type: "segment",
+			from: {
+				x: o - e.targetLength / 2,
+				y: s
+			},
+			to: {
+				x: o + e.targetLength / 2,
+				y: s
+			}
+		};
+	}
+};
+//#endregion
+//#region src/validation/goals/throughPoints.ts
+function ue(e, t) {
+	if (e.length !== t.length) return !1;
+	if (e.length === 2) {
+		let [n, r] = e, [i, a] = t;
+		return f(n, i) && f(r, a) || f(n, a) && f(r, i);
+	}
+	throw Error(`satisfiesThroughPoints: unsupported point count ${e.length}`);
+}
+var Z = {
+	...h.throughPoints,
+	subject: "candidates",
+	accepts(e, t) {
+		return I(e, t.objectType);
+	},
+	satisfies(e, t, n) {
+		return ue(y(e.definition).map((e) => M(n.points, e)), t.pointIds.map((e) => M(n.points, e)));
+	},
+	isRelevantAttempt(e, t, n) {
+		let r = y(e.definition).map((e) => M(n.points, e)), i = t.pointIds.map((e) => M(n.points, e));
+		return r.some((e) => i.some((t) => f(e, t)));
+	},
+	buildRevealedAnswer(e, t) {
+		let [n, r] = e.pointIds.map((e) => M(t.points, e));
+		return W(e.objectType, n, r);
+	}
+}, de = Object.freeze({
+	create: ie,
+	throughPoints: Z,
+	perpendicular: ce,
+	parallel: se,
+	segmentLength: le,
+	midpoint: oe,
+	angleMeasure: Y,
+	angleBisector: q,
+	givenAngle: ae
+});
+function Q(e) {
+	let t = de[e];
+	if (!t) throw Error(`No goal kind handler registered for "${e}"`);
+	return t;
+}
+function fe(e) {
+	let t = Q(e.type);
+	return t.subject === "figure" ? t : null;
+}
+function $(e) {
+	let t = Q(e.type);
+	return t.subject === "candidates" ? t : null;
+}
+function pe(e) {
+	return Q(e.type).referencedGivenIds(e);
+}
+function me(e, t) {
+	return $(t)?.accepts(e, t) ?? !1;
+}
+function he(e, t, n) {
+	let r = $(t);
+	return r !== null && r.accepts(e, t) && r.satisfies(e, t, n);
+}
+function ge(e, t, n) {
+	let r = $(t);
+	return r !== null && r.accepts(e, t) && r.isRelevantAttempt(e, t, n);
+}
+function _e(e, t) {
+	return $(e)?.buildRevealedAnswer(e, t) ?? null;
+}
+//#endregion
+export { ge as a, j as c, k as d, D as f, he as i, O as l, Q as n, pe as o, b as p, me as r, _e as s, fe as t, A as u };
+
+//# sourceMappingURL=goals-BlSeniyt.js.map