@pie-element/explicit-constructed-response 11.1.1-next.11 → 11.1.2-next.0

package/configure.js

@@ -0,0 +1,2 @@
+export { default } from './dist/author/index.js';
+export * from './dist/author/index.js';

package/controller.js

@@ -0,0 +1 @@
+export * from './dist/controller/index.js';

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,4 @@
+//#region \0rolldown/runtime.js
+var e = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports);
+//#endregion
+export { e as __commonJSMin };

package/dist/author/alternateResponses.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @synced-from pie-elements/packages/explicit-constructed-response/configure/src/alternateResponses.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 AlternateResponses extends React.Component {
+    static propTypes: {
+        choicesErrors: PropTypes.Requireable<object>;
+        model: PropTypes.Validator<object>;
+        onChange: PropTypes.Validator<(...args: any[]) => any>;
+        onLengthChange: PropTypes.Validator<(...args: any[]) => any>;
+        maxLengthPerChoiceEnabled: PropTypes.Validator<boolean>;
+        spellCheck: PropTypes.Requireable<boolean>;
+        pluginProps: PropTypes.Requireable<object>;
+    };
+    state: {
+        maxLengthPerChoice: any;
+    };
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentDidMount(): void;
+    updateChoicesIfNeeded: any;
+    getRemainingChoices: any;
+    onChoiceChanged: any;
+    onChoiceRemoved: any;
+    onSectionSelect: any;
+    onLengthChanged: any;
+    render(): React.JSX.Element;
+}
+export default AlternateResponses;

package/dist/author/alternateResponses.js

@@ -0,0 +1,116 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/cloneDeep.js";
+import t from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/map.js";
+import n from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isEqual.js";
+import r from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/reduce.js";
+import i from "./alternateSection.js";
+import a from "react";
+import o from "prop-types";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+//#region src/author/alternateResponses.tsx
+var l = class extends a.Component {
+	static propTypes = {
+		choicesErrors: o.object,
+		model: o.object.isRequired,
+		onChange: o.func.isRequired,
+		onLengthChange: o.func.isRequired,
+		maxLengthPerChoiceEnabled: o.bool.isRequired,
+		spellCheck: o.bool,
+		pluginProps: o.object
+	};
+	state = { maxLengthPerChoice: e(this.props.model.maxLengthPerChoice) };
+	UNSAFE_componentWillReceiveProps(e) {
+		this.updateChoicesIfNeeded(e);
+	}
+	componentDidMount() {
+		this.updateChoicesIfNeeded(this.props);
+	}
+	updateChoicesIfNeeded = (t) => {
+		if (!this.state.choices || !n(this.state.choices, t.model.choices) || !n(t.model.choices, this.props.model.choices) || this.state.values && Object.keys(this.state.values).length !== Object.keys(this.props.model.choices).length || t.maxLengthPerChoiceEnabled !== this.props.maxLengthPerChoiceEnabled) {
+			let { choices: n, maxLengthPerChoice: i } = t.model, a = r(n, (e, n, r) => (n && (t.maxLengthPerChoiceEnabled || n.length > 1) && (e[r] = n[0]), e), {});
+			this.setState({
+				choices: t.model.choices,
+				values: a,
+				maxLengthPerChoice: e(i)
+			});
+		}
+	};
+	getRemainingChoices = (e) => {
+		let { choices: t } = this.state;
+		return r(t, (t, n, r) => (n && n.length === 1 && !e && t.push({
+			label: n[0].label,
+			value: r
+		}), t), []);
+	};
+	onChoiceChanged = (e, t) => {
+		let { onChange: n } = this.props, { choices: r } = this.state, i = r[t] || [], a = !i.find((t) => t.value === e.value), o = i.reduce((t, n) => {
+			let r = n.value === e.value ? e : n;
+			return t.push(r), t;
+		}, []);
+		a && o.push(e), n({
+			...r,
+			[t]: o
+		});
+	};
+	onChoiceRemoved = (e, t) => {
+		let { onChange: n } = this.props, { choices: r } = this.state, i = (r[t] || []).reduce((t, n) => (n.value === e || t.push(n), t), []);
+		n({
+			...r,
+			[t]: i
+		});
+	};
+	onSectionSelect = (e, t) => {
+		let { onChange: n } = this.props, { choices: r, values: i } = this.state;
+		r[t] && r[t].length > 1 ? e || n({
+			...r,
+			[t]: [r[t][0]]
+		}) : this.setState({
+			choices: {
+				...r,
+				[t]: [...r[t], {
+					label: "",
+					value: "1"
+				}]
+			},
+			values: {
+				...i,
+				[t]: r[t][0]
+			}
+		});
+	};
+	onLengthChanged = (e, t) => {
+		let { model: n, onLengthChange: r } = this.props, { maxLengthPerChoice: i } = n;
+		i[t] = e, r(i);
+	};
+	render() {
+		let { choices: e } = this.state, { model: { maxLengthPerChoice: n, maxLengthPerChoiceEnabled: r }, spellCheck: a, choicesErrors: o, pluginProps: l } = this.props;
+		return /* @__PURE__ */ c("div", { children: [t(e, (e, t) => {
+			if (e && (r || e.length > 1)) {
+				let c = this.state.values[t];
+				return /* @__PURE__ */ s(i, {
+					value: c && c.value,
+					errors: o && o[t],
+					onSelect: (e) => this.onSectionSelect(e, t),
+					choiceChanged: (e) => this.onChoiceChanged(e, t),
+					choiceRemoved: (e) => this.onChoiceRemoved(e, t),
+					lengthChanged: (e) => this.onLengthChanged(e, t),
+					selectChoices: [c],
+					choices: e,
+					maxLength: n[t],
+					showMaxLength: r,
+					spellCheck: a,
+					pluginProps: l
+				}, t);
+			}
+		}), e && Object.keys(this.state.values).length !== Object.keys(e).length && /* @__PURE__ */ s(i, {
+			value: "",
+			onSelect: (e) => this.onSectionSelect(e, e.value),
+			choiceChanged: (e) => this.onChoiceChanged(e),
+			choiceRemoved: (e) => this.onChoiceRemoved(e),
+			selectChoices: this.getRemainingChoices(),
+			spellCheck: a,
+			pluginProps: l
+		})] });
+	}
+};
+//#endregion
+export { l as default };

package/dist/author/alternateSection.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @synced-from pie-elements/packages/explicit-constructed-response/configure/src/alternateSection.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 Choice extends React.Component {
+    static propTypes: {
+        error: PropTypes.Requireable<string>;
+        markup: PropTypes.Requireable<string>;
+        onChange: PropTypes.Validator<(...args: any[]) => any>;
+        onDelete: PropTypes.Validator<(...args: any[]) => any>;
+        value: PropTypes.Requireable<string>;
+        spellCheck: PropTypes.Requireable<boolean>;
+        showMaxLength: PropTypes.Requireable<boolean>;
+        pluginProps: PropTypes.Requireable<object>;
+    };
+    state: {
+        value: any;
+    };
+    updateText: any;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    onChange: any;
+    onKeyDown: any;
+    render(): React.JSX.Element;
+}
+export declare class AlternateSection extends React.Component {
+    static propTypes: {
+        choices: PropTypes.Requireable<any[]>;
+        selectChoices: PropTypes.Validator<any[]>;
+        errors: PropTypes.Requireable<object>;
+        onSelect: PropTypes.Validator<(...args: any[]) => any>;
+        choiceChanged: PropTypes.Validator<(...args: any[]) => any>;
+        lengthChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        choiceRemoved: PropTypes.Validator<(...args: any[]) => any>;
+        value: PropTypes.Requireable<string>;
+        maxLength: PropTypes.Requireable<number>;
+        showMaxLength: PropTypes.Requireable<boolean>;
+        spellCheck: PropTypes.Requireable<boolean>;
+        pluginProps: PropTypes.Requireable<object>;
+    };
+    state: {};
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentDidMount(): void;
+    updateChoicesIfNeeded: any;
+    handleSelect: any;
+    onAddChoice: any;
+    onChoiceChanged: any;
+    onRemoveChoice: any;
+    getChoicesMaxLength: any;
+    changeLength: any;
+    render(): React.JSX.Element;
+}
+export default AlternateSection;

package/dist/author/alternateSection.js

@@ -0,0 +1,215 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/debounce.js";
+import t from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isEqual.js";
+import n from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/max.js";
+import { decodeHTML as r, getAdjustedLength as i, stripHtmlTags as a } from "./markupUtils.js";
+import o from "react";
+import s from "prop-types";
+import { jsx as c, jsxs as l } from "react/jsx-runtime";
+import { styled as u } from "@mui/material/styles";
+import d from "@pie-lib/editable-html-tip-tap";
+import f from "@mui/material/Button";
+import p from "@mui/icons-material/Delete";
+import m from "@mui/material/IconButton";
+import h from "@mui/material/MenuItem";
+import g from "@mui/material/Select";
+import _ from "@mui/material/TextField";
+//#region src/author/alternateSection.tsx
+var v = u("div")(({ theme: e }) => ({ marginBottom: e.spacing(.5) })), y = u("div")(({ theme: e }) => ({
+	alignItems: "flex-start",
+	flexDirection: "column",
+	display: "flex",
+	paddingTop: e.spacing(2.5),
+	"& > *": {
+		marginBottom: e.spacing(2.5),
+		width: "100%"
+	}
+})), b = u(d)(({ theme: e, hasError: t }) => ({
+	flex: "1",
+	marginRight: e.spacing(2.5),
+	...t && {
+		border: `2px solid ${e.palette.error.main}`,
+		borderRadius: "6px"
+	}
+})), x = u(m)(({ theme: e }) => ({ "& svg": { fill: e.palette.grey[600] } })), S = u("div")({
+	alignItems: "flex-end",
+	display: "flex",
+	justifyContent: "space-between",
+	width: "100%"
+}), C = u("div")({
+	alignItems: "center",
+	display: "flex"
+}), w = u(_)(({ theme: e }) => ({
+	width: "230px",
+	marginRight: e.spacing(2.5),
+	"& .MuiInput-underline:before": { borderBottomColor: e.palette.divider },
+	"& .MuiInput-underline:hover:not(.Mui-disabled):before": { borderBottomColor: e.palette.text.primary },
+	"& .MuiInput-underline:after": { borderBottomColor: e.palette.primary.main }
+})), T = u("div")(({ theme: e }) => ({
+	fontSize: e.typography.fontSize - 2,
+	color: e.palette.error.main,
+	paddingTop: e.spacing(.5)
+})), E = u("div")({
+	alignItems: "center",
+	display: "flex",
+	justifyContent: "space-between"
+}), D = class extends o.Component {
+	static propTypes = {
+		error: s.string,
+		markup: s.string,
+		onChange: s.func.isRequired,
+		onDelete: s.func.isRequired,
+		value: s.string,
+		spellCheck: s.bool,
+		showMaxLength: s.bool,
+		pluginProps: s.object
+	};
+	state = { value: this.props.markup };
+	updateText = e(this.props.onChange, 300);
+	UNSAFE_componentWillReceiveProps(e) {
+		e.markup && this.setState({ value: e.markup });
+	}
+	onChange = (e) => {
+		let t = a(e);
+		this.setState({ value: t }), this.updateText(t);
+	};
+	onKeyDown = (e) => {
+		if (e.key === "Enter") return !0;
+	};
+	render() {
+		let { value: e } = this.state, { onDelete: t, spellCheck: n, error: r, showMaxLength: i, pluginProps: a } = this.props, s = i ? {} : { maxLength: 25 };
+		return /* @__PURE__ */ l(o.Fragment, { children: [/* @__PURE__ */ l(E, { children: [/* @__PURE__ */ c(b, {
+			hasError: !!r,
+			disableUnderline: !0,
+			onChange: this.onChange,
+			onKeyDown: this.onKeyDown,
+			markup: e || "",
+			activePlugins: ["languageCharacters"],
+			pluginProps: a,
+			languageCharactersProps: [{ language: "spanish" }],
+			spellCheck: n,
+			autoWidthToolbar: !0,
+			toolbarOpts: {
+				minWidth: "auto",
+				isHidden: !!a?.characters?.disabled
+			},
+			...s
+		}), /* @__PURE__ */ c(x, {
+			"aria-label": "delete",
+			onClick: t,
+			size: "large",
+			children: /* @__PURE__ */ c(p, {})
+		})] }), r && /* @__PURE__ */ c(T, { children: r })] });
+	}
+}, O = class extends o.Component {
+	static propTypes = {
+		choices: s.array,
+		selectChoices: s.array.isRequired,
+		errors: s.object,
+		onSelect: s.func.isRequired,
+		choiceChanged: s.func.isRequired,
+		lengthChanged: s.func,
+		choiceRemoved: s.func.isRequired,
+		value: s.string,
+		maxLength: s.number,
+		showMaxLength: s.bool,
+		spellCheck: s.bool,
+		pluginProps: s.object
+	};
+	state = {};
+	UNSAFE_componentWillReceiveProps(e) {
+		this.updateChoicesIfNeeded(e);
+	}
+	componentDidMount() {
+		this.updateChoicesIfNeeded(this.props);
+	}
+	updateChoicesIfNeeded = (e) => {
+		(!this.state.choices || !t(e.choices, this.state.choices) || !t(e.choices, this.props.choices)) && this.setState({ choices: e.choices });
+	};
+	handleSelect = (e) => {
+		let { onSelect: t, selectChoices: n } = this.props, { value: r } = e.target;
+		t(n.find((e) => e.value === r));
+	};
+	onAddChoice = () => {
+		let { choices: e } = this.state;
+		if (e.length && e[e.length - 1].label !== "") {
+			let t = n(e.map((e) => parseInt(e.value)).filter((e) => !isNaN(e))) || 0;
+			this.setState({ choices: [...e, {
+				value: `${t + 1}`,
+				label: ""
+			}] });
+		}
+	};
+	onChoiceChanged = (e, t, n) => {
+		let { choiceChanged: a, lengthChanged: o, maxLength: s, choices: c } = this.props, l = c.map((e) => r(e.label || "").length);
+		l[n] = r(t).length;
+		let u = Math.max(...l);
+		a({
+			...e,
+			label: t
+		}), (u > s || u + 10 <= s) && o(i(u));
+	};
+	onRemoveChoice = (e) => {
+		let { choiceRemoved: t } = this.props;
+		t(e.value);
+	};
+	getChoicesMaxLength = () => {
+		let { choices: e } = this.state;
+		if (!e) return 1;
+		let t = e.map((e) => r(e.label || "").length);
+		return Math.max(...t);
+	};
+	changeLength = (e) => {
+		let { lengthChanged: t } = this.props, n = parseInt(e.target.value, 10), r = this.getChoicesMaxLength();
+		n && n >= r && n <= r + 10 && t(n);
+	};
+	render() {
+		let { selectChoices: e, maxLength: t, showMaxLength: n, value: i, spellCheck: a, errors: o, pluginProps: s } = this.props, { choices: u } = this.state, d = this.getChoicesMaxLength();
+		return /* @__PURE__ */ l(v, { children: [
+			/* @__PURE__ */ l(S, { children: [/* @__PURE__ */ l(g, {
+				variant: "standard",
+				displayEmpty: !0,
+				onChange: this.handleSelect,
+				value: i || "",
+				readOnly: n,
+				MenuProps: { transitionDuration: {
+					enter: 225,
+					exit: 195
+				} },
+				children: [/* @__PURE__ */ c(h, {
+					value: "",
+					children: /* @__PURE__ */ c("em", { children: i ? "Remove selection" : "Select a response" })
+				}), e.map((e, t) => /* @__PURE__ */ c(h, {
+					value: e?.value,
+					children: r(e?.label)
+				}, t))]
+			}), u && u.length > 0 && /* @__PURE__ */ l(C, { children: [t && n && /* @__PURE__ */ c(w, {
+				variant: "standard",
+				label: "Maximum length (characters)",
+				type: "number",
+				inputProps: {
+					min: d,
+					max: d + 10
+				},
+				value: t,
+				onChange: this.changeLength
+			}), /* @__PURE__ */ c(f, {
+				variant: "contained",
+				color: "primary",
+				onClick: this.onAddChoice,
+				children: "Add"
+			})] })] }),
+			o && o[0] && /* @__PURE__ */ c(T, { children: o[0] }),
+			/* @__PURE__ */ c(y, { children: u && u.map((e, t) => t > 0 && /* @__PURE__ */ c(D, {
+				markup: e.label,
+				onChange: (n) => this.onChoiceChanged(e, n, t),
+				onDelete: () => this.onRemoveChoice(e),
+				spellCheck: a,
+				error: o && o[t],
+				showMaxLength: n,
+				pluginProps: s
+			}, t)) })
+		] });
+	}
+};
+//#endregion
+export { O as default };

package/dist/author/defaults.d.ts

@@ -0,0 +1,186 @@
+/**
+ * @synced-from pie-elements/packages/explicit-constructed-response/configure/src/defaults.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 _default: {
+    model: {
+        choices: {};
+        displayType: string;
+        markup: string;
+        maxLengthPerChoiceEnabled: boolean;
+        playerSpellCheckEnabled: boolean;
+        prompt: string;
+        promptEnabled: boolean;
+        rationale: string;
+        rationaleEnabled: boolean;
+        spellCheckEnabled: boolean;
+        studentInstructionsEnabled: boolean;
+        teacherInstructions: string;
+        teacherInstructionsEnabled: boolean;
+        toolbarEditorPosition: string;
+        responseAreaInputConfiguration: {};
+    };
+    configuration: {
+        baseInputConfiguration: {
+            h3: {
+                disabled: boolean;
+            };
+            html: {
+                disabled: boolean;
+            };
+            audio: {
+                disabled: boolean;
+            };
+            video: {
+                disabled: boolean;
+            };
+            image: {
+                disabled: boolean;
+            };
+            textAlign: {
+                disabled: boolean;
+            };
+            showParagraphs: {
+                disabled: boolean;
+            };
+            separateParagraphs: {
+                disabled: boolean;
+            };
+        };
+        prompt: {
+            settings: boolean;
+            label: string;
+            inputConfiguration: {
+                audio: {
+                    disabled: boolean;
+                };
+                video: {
+                    disabled: boolean;
+                };
+                image: {
+                    disabled: boolean;
+                };
+            };
+            required: boolean;
+        };
+        partialScoring: {
+            settings: boolean;
+            label: string;
+        };
+        rationale: {
+            settings: boolean;
+            label: string;
+            inputConfiguration: {
+                audio: {
+                    disabled: boolean;
+                };
+                video: {
+                    disabled: boolean;
+                };
+                image: {
+                    disabled: boolean;
+                };
+            };
+            required: boolean;
+        };
+        settingsPanelDisabled: boolean;
+        spellCheck: {
+            label: string;
+            settings: boolean;
+            enabled: boolean;
+        };
+        editSource: {
+            label: string;
+            settings: boolean;
+            enabled: boolean;
+        };
+        playerSpellCheck: {
+            label: string;
+            settings: boolean;
+            enabled: boolean;
+        };
+        teacherInstructions: {
+            settings: boolean;
+            label: string;
+            inputConfiguration: {
+                audio: {
+                    disabled: boolean;
+                };
+                video: {
+                    disabled: boolean;
+                };
+                image: {
+                    disabled: boolean;
+                };
+            };
+            required: boolean;
+        };
+        template: {
+            inputConfiguration: {
+                audio: {
+                    disabled: boolean;
+                };
+                video: {
+                    disabled: boolean;
+                };
+                image: {
+                    disabled: boolean;
+                };
+                h3: {
+                    disabled: boolean;
+                };
+                blockquote: {
+                    disabled: boolean;
+                };
+            };
+        };
+        maxLengthPerChoice: {
+            settings: boolean;
+            label: string;
+        };
+        maxResponseAreas: number;
+        maxImageWidth: {
+            teacherInstructions: number;
+            prompt: number;
+            rationale: number;
+        };
+        maxImageHeight: {
+            teacherInstructions: number;
+            prompt: number;
+            rationale: number;
+        };
+        withRubric: {
+            settings: boolean;
+            label: string;
+        };
+        mathMlOptions: {
+            mmlOutput: boolean;
+            mmlEditing: boolean;
+        };
+        language: {
+            settings: boolean;
+            label: string;
+            enabled: boolean;
+        };
+        languageChoices: {
+            label: string;
+            options: never[];
+        };
+        responseAreaInputConfiguration: {
+            inputConfiguration: {
+                characters: {
+                    disabled: boolean;
+                };
+            };
+        };
+        spanishButton: {
+            settings: boolean;
+            label: string;
+        };
+    };
+};
+export default _default;