@pie-element/graphing 0.1.0

package/dist/controller/utils.js

@@ -0,0 +1,111 @@
+import e from "../node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/differenceWith.js";
+import t from "../node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/isEqual.js";
+import n from "../node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/uniq.js";
+import r from "../node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/uniqWith.js";
+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 }, (e.label || n.label) && t(e.label, n.label), t(e.x, n.x) && t(e.y, n.y)), l = (e, n) => t(e.from, n.from) && t(e.to, n.to) || t(e.to, n.from) && t(e.from, n.to), u = (e, n) => t(e.from, n.from) && t(e.to, n.to), d = (e) => Object.keys(e || {}).sort().reduce((t, n) => (n !== "correctAnswer" && (t[n] = e[n]), t), {}), f = (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;
+	return {
+		a: i - n,
+		b: t - r,
+		c: r * n - t * i
+	};
+}, p = (e) => Math.round(e * 1e4) / 1e4, m = (e, t) => {
+	let { a: r, b: i, c: a } = f(e), { a: o, b: s, c } = f(t), l = [];
+	if (o !== 0) l.push(p(r / o));
+	else if (r !== o) return !1;
+	if (s !== 0) l.push(p(i / s));
+	else if (i !== s) return !1;
+	if (c !== 0) l.push(p(a / c));
+	else if (a !== c) return !1;
+	return n(l).length === 1;
+}, h = (e, t) => {
+	e = {
+		...e,
+		to: { ...e.to },
+		from: { ...e.from }
+	}, t = {
+		...t,
+		to: { ...t.to },
+		from: { ...t.from }
+	};
+	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;
+}, g = (e) => (e || []).map((t, n) => ({
+	from: t,
+	to: e[(n + 1) % e.length]
+})), _ = (e) => (e ||= [], r(e, (e, t) => l(e, t))), v = (e) => (e ||= [], e.filter((e) => !t(e.from, e.to))), y = (t, n) => {
+	let { points: r } = t, { points: i } = n, a = g(r), o = g(i), s = _(v(a)), c = _(v(o)), u = e(s, c, l), d = e(c, s, l);
+	return (!u || !u.length) && (!d || !d.length);
+}, b = (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);
+}, x = (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;
+		return {
+			amplitude: p(n),
+			freq: p(r),
+			min: p(t.y < e.y ? t.y : t.y - a),
+			max: p(t.y < e.y ? t.y + a : t.y),
+			edgeAboveZeroX: p(s),
+			edgeAboveZeroY: p(c)
+		};
+	}, r = n(e), a = n(t), { amplitude: o, freq: s, min: c, max: l, edgeAboveZeroX: u, edgeAboveZeroY: d } = r, { amplitude: f, freq: m, min: h, max: g, edgeAboveZeroX: _, edgeAboveZeroY: v } = a;
+	return Math.abs(o) === Math.abs(f) && Math.abs(s) === Math.abs(m) && c === h && l === g && u === _ && d === v;
+}, S = (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 = {
+		x: i.x - (s.x - i.x),
+		y: s.y
+	}, u = {
+		x: o.x - (c.x - o.x),
+		y: c.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);
+}, C = (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);
+}, w = (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 }, { a1: u, b1: d } = o(a, c), { a2: f, b2: p } = o(s, l);
+	return t(f, u) && t(p, d);
+}, T = {
+	circle: (e, t) => b(e, t),
+	line: (e, t) => m(e, t),
+	parabola: (e, t) => S(e, t),
+	absolute: (e, t) => C(e, t),
+	exponential: (e, t) => w(e, t),
+	point: (e, t) => c(e, t),
+	polygon: (e, t) => y(e, t),
+	ray: (e, t) => h(e, t),
+	segment: (e, t) => l(e, t),
+	sine: (e, t) => x(e, t),
+	vector: (e, t) => u(e, t)
+};
+//#endregion
+export { T as equalMarks, d as sortedAnswers };

package/dist/delivery/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @synced-from pie-elements/packages/graphing/src/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 Main from './main.js';
+export { Main as Component };
+export default class Graphing extends HTMLElement {
+    constructor();
+    set model(m: any);
+    set session(s: any);
+    get session(): any;
+    connectedCallback(): void;
+    isComplete: (answer: any) => boolean;
+    changeAnswers: any;
+    _render(): void;
+    disconnectedCallback(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/delivery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/delivery/index.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAOH,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,CAAC;AAE7B,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,WAAW;;IAM/C,IAAI,KAAK,CAAC,CAAC,KAAA,EAGV;IAED,IAAI,OAAO,CAAC,CAAC,KAAA,EAGZ;IAED,IAAI,OAAO,QAEV;IAED,iBAAiB;IAIjB,UAAU,GAAI,WAAM,aAAgD;IAEpE,aAAa,EAAE,GAAG,CAMhB;IAEF,OAAO;IAoBP,oBAAoB;CAKrB"}

package/dist/delivery/index.js

@@ -0,0 +1,43 @@
+import e from "./main.js";
+import t from "react";
+import { createRoot as n } from "react-dom/client";
+import { SessionChangedEvent as r } from "@pie-element/shared-player-events";
+import { renderMath as i } from "@pie-element/shared-math-rendering-mathjax";
+//#region src/delivery/index.ts
+var a = class extends HTMLElement {
+	constructor() {
+		super(), this._root = null;
+	}
+	set model(e) {
+		this._model = e, this._render();
+	}
+	set session(e) {
+		this._session = e, this._render();
+	}
+	get session() {
+		return this._session;
+	}
+	connectedCallback() {
+		this._render();
+	}
+	isComplete = (e) => Array.isArray(e) && e.length > 0;
+	changeAnswers = (e) => {
+		this._session.answer = e, this.dispatchEvent(new r(this.tagName.toLowerCase(), this.isComplete(this._session.answer))), this._render();
+	};
+	_render() {
+		if (!this._model || !this._session) return;
+		let r = t.createElement(e, {
+			model: this._model,
+			session: this._session,
+			onAnswersChange: this.changeAnswers
+		});
+		this._root ||= n(this), this._root.render(r), queueMicrotask(() => {
+			i(this);
+		});
+	}
+	disconnectedCallback() {
+		this._root && this._root.unmount();
+	}
+};
+//#endregion
+export { e as Component, a as default };

package/dist/delivery/main.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @synced-from pie-elements/packages/graphing/src/main.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 class Main extends React.Component {
+    static propTypes: {
+        model: PropTypes.Validator<object>;
+        session: PropTypes.Validator<object>;
+        onAnswersChange: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    state: {
+        showingCorrect: boolean;
+    };
+    toggleCorrect: (showingCorrect: any) => void;
+    render(): React.JSX.Element;
+}
+export default Main;
+//# sourceMappingURL=main.d.ts.map

package/dist/delivery/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/delivery/main.tsx"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,SAAS,MAAM,YAAY,CAAC;AAkDnC,qBAAa,IAAK,SAAQ,KAAK,CAAC,SAAS;IACvC,MAAM,CAAC,SAAS;;;;MAId;IAEF,KAAK;;MAA6B;IAElC,aAAa,GAAI,mBAAc,UAAuC;IAEtE,MAAM;CAyGP;AAED,eAAe,IAAI,CAAC"}

package/dist/delivery/main.js

@@ -0,0 +1,107 @@
+import e from "react";
+import t from "prop-types";
+import { styled as n } from "@mui/material/styles";
+import { GraphContainer as r, KeyLegend as i } from "@pie-lib/graphing";
+import * as a from "@pie-lib/render-ui";
+import { Collapsible as o, PreviewPrompt as s, UiLayout as c, color as l, hasMedia as u, hasText as d } from "@pie-lib/render-ui";
+import { jsx as f, jsxs as p } from "react/jsx-runtime";
+import m from "@pie-lib/correct-answer-toggle";
+//#region src/delivery/main.tsx
+function h(e) {
+	return typeof e == "function" || typeof e == "object" && !!e && typeof e.$$typeof == "symbol";
+}
+function g(e, t) {
+	return !e || h(e) ? e : h(e.default) ? e.default : t && h(e[t]) ? e[t] : t && h(e[t]?.default) ? e[t].default : e;
+}
+var _ = g(c, "UiLayout") || g(S.UiLayout, "UiLayout"), v = g(s, "PreviewPrompt") || g(S.PreviewPrompt, "PreviewPrompt"), y = g(o, "Collapsible") || g(S.Collapsible, "Collapsible"), b = a, x = b.default, S = x && typeof x == "object" ? x : b, C = n(_)({
+	color: l.text(),
+	backgroundColor: l.background()
+}), w = n(y)(({ theme: e }) => ({ marginBottom: e.spacing(2) })), T = n(r)(({ theme: e }) => ({
+	marginTop: e.spacing(2),
+	marginBottom: e.spacing(2)
+})), E = class extends e.Component {
+	static propTypes = {
+		model: t.object.isRequired,
+		session: t.object.isRequired,
+		onAnswersChange: t.func
+	};
+	state = { showingCorrect: !1 };
+	toggleCorrect = (e) => this.setState({ showingCorrect: e });
+	render() {
+		let { model: e, onAnswersChange: t, session: n } = this.props, { showingCorrect: r } = this.state, { answer: a } = n || {}, { answersCorrected: o, arrows: s, backgroundMarks: c, coordinatesOnHover: l, correctResponse: h, defaultTool: g, disabled: _, domain: b, extraCSSRules: x, labels: S, labelsEnabled: E, prompt: D, range: O, rationale: k, showKeyLegend: A, showToggle: j, title: M, titleEnabled: N, teacherInstructions: P, toolbarTools: F, language: I } = e || {}, L = e?.size || e?.graph || {}, R = o || a || [], z = F?.includes("label") || !1, B = e.rationale && (d(e.rationale) || u(e.rationale));
+		return /* @__PURE__ */ p(C, {
+			extraCSSRules: x,
+			children: [
+				e.teacherInstructions && (d(e.teacherInstructions) || u(e.teacherInstructions)) && /* @__PURE__ */ f(w, {
+					labels: {
+						hidden: "Show Teacher Instructions",
+						visible: "Hide Teacher Instructions"
+					},
+					children: /* @__PURE__ */ f(v, { prompt: P })
+				}),
+				D && /* @__PURE__ */ f(v, {
+					className: "prompt",
+					prompt: D
+				}),
+				/* @__PURE__ */ f(m, {
+					show: j,
+					toggled: r,
+					onToggle: this.toggleCorrect,
+					language: I
+				}),
+				r && j ? /* @__PURE__ */ f(T, {
+					axesSettings: { includeArrows: s },
+					backgroundMarks: c.filter((e) => !e.building),
+					coordinatesOnHover: l,
+					disabled: !0,
+					disabledLabels: !0,
+					disabledTitle: !0,
+					domain: b,
+					labels: S,
+					marks: h.map((e) => ({
+						...e,
+						correctness: "correct"
+					})),
+					onChangeMarks: t,
+					range: O,
+					showLabels: E,
+					showTitle: N,
+					size: L,
+					title: M,
+					toolbarTools: F,
+					language: I
+				}) : /* @__PURE__ */ f(T, {
+					axesSettings: { includeArrows: s },
+					backgroundMarks: c.filter((e) => !e.building),
+					coordinatesOnHover: l,
+					defaultTool: g,
+					disabled: _,
+					disabledLabels: !0,
+					disabledTitle: !0,
+					domain: b,
+					labels: S,
+					marks: R,
+					onChangeMarks: t,
+					range: O,
+					showLabels: E,
+					showTitle: N,
+					size: L,
+					title: M,
+					toolbarTools: F,
+					language: I,
+					limitLabeling: !0
+				}),
+				A && !r && /* @__PURE__ */ f(i, { isLabelAvailable: z }),
+				B && /* @__PURE__ */ f(y, {
+					labels: {
+						hidden: "Show Rationale",
+						visible: "Hide Rationale"
+					},
+					children: /* @__PURE__ */ f(v, { prompt: k })
+				})
+			]
+		});
+	}
+};
+//#endregion
+export { E as default };

package/dist/delivery/utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @synced-from pie-elements/packages/graphing/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.
+ */
+declare const completeMark: {
+    point: (point: any) => any;
+    line: (item: any) => any;
+    ray: (item: any) => any;
+    segment: (item: any) => any;
+    vector: (item: any) => any;
+    circle: (item: any) => any;
+    parabola: (item: any) => any;
+    absolute: (item: any) => any;
+    exponential: (item: any) => any;
+    sine: (item: any) => any;
+    polygon: (item: any) => any;
+};
+export { completeMark };
+//# sourceMappingURL=utils.d.ts.map

package/dist/delivery/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/delivery/utils.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAWH,QAAA,MAAM,YAAY;;;;;;;;;;;;CAYjB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}