@pie-element/categorize 13.1.0-next.19 → 13.1.1-next.1

package/dist/author/main.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @synced-from pie-elements/packages/categorize/configure/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: {
+        configuration: PropTypes.Requireable<object>;
+        onConfigurationChanged: PropTypes.Requireable<(...args: any[]) => any>;
+        model: PropTypes.Validator<object>;
+        onModelChanged: PropTypes.Validator<(...args: any[]) => any>;
+        imageSupport: PropTypes.Requireable<object>;
+        uploadSoundSupport: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {};
+    render(): React.JSX.Element;
+}
+export default Main;

package/dist/author/main.js

@@ -0,0 +1,30 @@
+import e from "./design/index.js";
+import t from "react";
+import n from "prop-types";
+import { jsx as r } from "react/jsx-runtime";
+//#region src/author/main.tsx
+var i = class extends t.Component {
+	static propTypes = {
+		configuration: n.object,
+		onConfigurationChanged: n.func,
+		model: n.object.isRequired,
+		onModelChanged: n.func.isRequired,
+		imageSupport: n.object,
+		uploadSoundSupport: n.object
+	};
+	static defaultProps = {};
+	render() {
+		let { model: t, onModelChanged: n, configuration: i, onConfigurationChanged: a, imageSupport: o, uploadSoundSupport: s } = this.props;
+		return /* @__PURE__ */ r(e, {
+			imageSupport: o,
+			uploadSoundSupport: s,
+			title: "Design",
+			model: t,
+			configuration: i,
+			onChange: n,
+			onConfigurationChanged: a
+		});
+	}
+};
+//#endregion
+export { i as default };

package/dist/author/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @synced-from pie-elements/packages/categorize/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 generateValidationMessage: (config: any) => string;
+export declare const multiplePlacements: {
+    enabled: string;
+    disabled: string;
+    perChoice: string;
+};
+export declare const maxLength: (array: any) => any;
+export declare const getMaxCategoryChoices: (model: any) => any;

package/dist/author/utils.js

@@ -0,0 +1,17 @@
+//#region src/author/utils.ts
+var e = (e) => {
+	let { minChoices: t, maxChoices: n, maxCategories: r } = e || {};
+	return t ||= 1, "Validation requirements:" + ("\nThe choices content should not be empty and should be unique.\nThere should be at least 1 " + (r ? `and at most ${r} ` : "") + "category" + (r ? "s" : "") + " defined." + (t ? `\nThere should be at least ${t} choices defined.` : "") + (n ? `\nNo more than ${n} choices should be defined.` : "") + "\nAt least one token should be assigned to at least one category.");
+}, t = {
+	enabled: "Yes",
+	disabled: "No",
+	perChoice: "Set Per Choice"
+}, n = (e) => (e || []).reduce((e, t) => Math.max(e, t.length), 0), r = (e) => {
+	let { correctResponse: t = [] } = e || {};
+	return t.reduce((e, t) => {
+		let r = t?.choices?.length || 0, i = t?.alternateResponses || [], a = Math.max(r, n(i));
+		return a > e ? a : e;
+	}, 0);
+};
+//#endregion
+export { e as generateValidationMessage, r as getMaxCategoryChoices, t as multiplePlacements };

package/dist/controller/defaults.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @synced-from pie-elements/packages/categorize/controller/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: {
+    allowMultiplePlacementsEnabled: string;
+    alternates: never[];
+    categories: never[];
+    categoriesPerRow: number;
+    choices: never[];
+    choicesLabel: string;
+    choicesPosition: string;
+    correctResponse: never[];
+    feedbackEnabled: boolean;
+    lockChoiceOrder: boolean;
+    maxAnswerChoices: number;
+    maxChoicesPerCategory: number;
+    partialScoring: boolean;
+    prompt: string;
+    promptEnabled: boolean;
+    rationale: string;
+    rationaleEnabled: boolean;
+    rowLabels: string[];
+    studentInstructionsEnabled: boolean;
+    teacherInstructions: string;
+    teacherInstructionsEnabled: boolean;
+    toolbarEditorPosition: string;
+    minRowHeight: string;
+};
+export default _default;

package/dist/controller/defaults.js

@@ -0,0 +1,29 @@
+import { multiplePlacements as e } from "./utils.js";
+//#region src/controller/defaults.ts
+var t = {
+	allowMultiplePlacementsEnabled: e.enabled,
+	alternates: [],
+	categories: [],
+	categoriesPerRow: 2,
+	choices: [],
+	choicesLabel: "",
+	choicesPosition: "below",
+	correctResponse: [],
+	feedbackEnabled: !1,
+	lockChoiceOrder: !0,
+	maxAnswerChoices: 6,
+	maxChoicesPerCategory: 0,
+	partialScoring: !0,
+	prompt: "",
+	promptEnabled: !0,
+	rationale: "",
+	rationaleEnabled: !0,
+	rowLabels: [""],
+	studentInstructionsEnabled: !0,
+	teacherInstructions: "",
+	teacherInstructionsEnabled: !0,
+	toolbarEditorPosition: "bottom",
+	minRowHeight: "80px"
+};
+//#endregion
+export { t as default };

package/dist/controller/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @synced-from pie-elements/packages/categorize/controller/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 { score } from '@pie-lib/categorize';
+export { score };
+export declare const getPartialScore: (correctResponse: any, builtCategories: any) => number;
+export declare const getTotalScore: (question: any, session: any, env: any) => number;
+export declare const getCorrectness: (question: any, session: any, env: any) => Promise<unknown>;
+export declare const createDefaultModel: (model?: {}) => Promise<unknown>;
+export declare const normalize: (question: any) => any;
+/**
+ *
+ * @param {*} question
+ * @param {*} session
+ * @param {*} env
+ * @param {*} updateSession - optional - a function that will set the properties passed into it on the session.
+ */
+export declare const model: (question: any, session: any, env: any, updateSession: any) => Promise<{
+    categories: any;
+    categoriesPerRow: any;
+    maxChoicesPerCategory: any;
+    correctness: unknown;
+    choices: any;
+    choicesLabel: any;
+    choicesPosition: any;
+    disabled: boolean;
+    feedback: string | undefined;
+    lockChoiceOrder: boolean;
+    prompt: any;
+    rowLabels: any;
+    note: any;
+    env: any;
+    showNote: any;
+    correctResponse: any;
+    language: any;
+    extraCSSRules: any;
+    fontSizeFactor: any;
+    minRowHeight: any;
+    autoplayAudioEnabled: any;
+    completeAudioEnabled: any;
+    customAudioButton: any;
+    possibleResponses: any[];
+    responseAreasToBeFilled: any;
+    hasUnplacedChoices: boolean;
+}>;
+/**
+* Generates detailed trace log for scoring evaluation
+* @param {Object} model - the question model
+* @param {Object} session - the student session
+* @param {Object} env - the environment
+* @returns {Array} traceLog - array of trace messages
+*/
+export declare const getLogTrace: (model: any, session: any, env: any) => string[];
+export declare const outcome: (question: any, session: any, env: any) => Promise<unknown>;
+export declare const createCorrectResponseSession: (question: any, env: any) => Promise<unknown>;
+export declare const validate: (model?: {}, config?: {}) => {};

package/dist/controller/index.js

@@ -0,0 +1,155 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isEmpty.js";
+import { getCompleteResponseDetails as t, isAlternateDuplicated as n, isCorrectResponseDuplicated as r } from "./utils.js";
+import i from "./defaults.js";
+import { buildState as a, score as o } from "@pie-lib/categorize";
+import s from "@pie-lib/translator";
+import { getFeedbackForCorrectness as c } from "@pie-element/shared-feedback";
+import { getShuffledChoices as l, lockChoices as u, partialScoring as d } from "@pie-element/shared-controller-utils";
+//#region src/controller/index.ts
+var { translator: f } = s, p = (e, t) => {
+	let { placements: n, score: r } = t.reduce((e, { choices: t = [] }) => ({
+		placements: e.placements + t.length,
+		score: e.score + t.filter((e) => e.correct).length
+	}), {
+		placements: 0,
+		score: 0
+	}), { maxScore: i } = e.reduce((e, { choices: t }) => ({ maxScore: e.maxScore + t.length }), { maxScore: 0 }), a = (r - (n > i ? n - i : 0)) / i;
+	return a < 0 ? 0 : parseFloat(a.toFixed(2));
+}, m = (e) => e.map((e) => e.alternateResponses).filter((e) => e), h = (e, t, n) => {
+	if (!t || Object.keys(t).length === 0) return 0;
+	let { categories: r, choices: i } = e || {}, { correctResponse: o } = e || {}, { answers: s } = t || {};
+	s ||= [], o ||= [];
+	let { categories: c, correct: l } = a(r, i, s, o), u = m(o);
+	return d.enabled(e, n) && !u.length ? p(o, c) : +!!l;
+}, g = (e, t, n) => new Promise((r) => {
+	if (n.mode === "evaluate") {
+		let i = h(e, t, n);
+		r(i === 1 ? "correct" : i === 0 ? "incorrect" : "partially-correct");
+	} else r(void 0);
+}), _ = (e = {}) => new Promise((t) => {
+	t({
+		...i,
+		...e
+	});
+}), v = (e) => ({
+	...i,
+	...e
+}), y = async (e, n, r, i) => {
+	let a = v(e), o = await g(a, n, r), { mode: s, role: d } = r || {}, { categories: p, categoriesPerRow: h, choicesLabel: _, choicesPosition: y, correctResponse: b, feedback: x, feedbackEnabled: S, promptEnabled: C, prompt: w, rowLabels: T, rationaleEnabled: E, rationale: D, teacherInstructionsEnabled: O, teacherInstructions: k, language: A, maxChoicesPerCategory: j, extraCSSRules: M, minRowHeight: N, fontSizeFactor: P, autoplayAudioEnabled: F, completeAudioEnabled: I, customAudioButton: L } = a, { choices: R, note: z } = a, B, V = u(a, n, r), H = b.map((e) => {
+		let t = (e.choices || []).filter((e) => e !== "null");
+		return {
+			...e,
+			choices: t
+		};
+	});
+	s === "evaluate" && S && (B = await c(o, x)), V || (R = await l(R, n, i, "id")), z ||= f.t("common:commonCorrectAnswerWithAlternates", { lng: A });
+	let U = m(H), { responseAreasToBeFilled: W, possibleResponses: G, hasUnplacedChoices: K } = t(H, a.allowAlternateEnabled ? U : [], a.choices), q = {
+		categories: p || [],
+		categoriesPerRow: h || 2,
+		maxChoicesPerCategory: j,
+		correctness: o,
+		choices: R || [],
+		choicesLabel: _ || "",
+		choicesPosition: y,
+		disabled: s !== "gather",
+		feedback: B,
+		lockChoiceOrder: V,
+		prompt: C ? w : null,
+		rowLabels: T,
+		note: z,
+		env: r,
+		showNote: U && U.length > 0,
+		correctResponse: s === "evaluate" ? H : void 0,
+		language: A,
+		extraCSSRules: M,
+		fontSizeFactor: P,
+		minRowHeight: N,
+		autoplayAudioEnabled: F,
+		completeAudioEnabled: I,
+		customAudioButton: L,
+		possibleResponses: G,
+		responseAreasToBeFilled: W,
+		hasUnplacedChoices: K
+	};
+	return d === "instructor" && (s === "view" || s === "evaluate") ? (q.rationale = E ? D : null, q.teacherInstructions = O ? k : null) : (q.rationale = null, q.teacherInstructions = null), q;
+}, b = (e, t, n) => {
+	let r = [], { answers: i } = t || {}, { categories: o, choices: s, correctResponse: c } = e || {}, l = i.reduce((e, t) => e + (t.choices?.length || 0), 0), u = m(c).length > 0, f = d.enabled(e, n), p = (l > 0 ? a(o, s, i, c) : null)?.categories || [];
+	if (l > 0 ? (r.push(`Student placed ${l} choice(s) into categories.`), (o || []).forEach((e, t) => {
+		let n = e.id, i = p.find((e) => e.id === n), a = i && i.choices || [], o = (c || []).find((e) => e.category === n), s = o && o.choices || [];
+		if (s.length > 0) if (a.length === 0) r.push(`Category ${n}: student left empty (should contain ${s.length} choice(s)).`);
+		else {
+			let e = a.filter((e) => e.correct).length, t = a.length - e;
+			e > 0 && t === 0 ? r.push(`Category ${n}: student placed ${e} correct choice(s).`) : e === 0 && t > 0 ? r.push(`Category ${n}: student placed ${t} incorrect choice(s).`) : r.push(`Category ${n}: student placed ${e} correct and ${t} incorrect choice(s).`);
+		}
+	})) : r.push("Student did not place any choices into categories."), u && r.push("Alternate response combinations are accepted for this question."), u) r.push("Score calculated using all-or-nothing scoring (alternate responses disable partial scoring)."), r.push("Student must get all categories completely correct to receive full credit.");
+	else if (f) {
+		if (r.push("Score calculated using partial scoring."), r.push("Student receives credit for each correct placement, with deductions for incorrect placements beyond required amount."), l > 0) {
+			let e = p.reduce((e, t) => e + (t.choices || []).filter((e) => e.correct).length, 0), t = l - e, n = (c || []).reduce((e, t) => e + (t.choices || []).length, 0);
+			if (r.push(`Partial scoring calculation: ${e} correct placements, ${t} incorrect placements.`), l > n) {
+				let e = l - n;
+				r.push(`${e} extra placement(s) beyond required amount will be deducted from score.`);
+			}
+		}
+	} else r.push("Score calculated using all-or-nothing scoring."), r.push("Student must get all categories completely correct to receive full credit.");
+	let g = h(e, t, n);
+	return r.push(`Final score: ${g}.`), r;
+}, x = (t, n, r) => r.mode === "evaluate" ? new Promise((i) => {
+	if (!n || e(n)) i({
+		score: 0,
+		empty: !0,
+		traceLog: ["Student did not place any choices into categories. Score is 0."]
+	});
+	else {
+		let e = b(t, n, r);
+		i({
+			score: h(t, n, r),
+			empty: !1,
+			traceLog: e
+		});
+	}
+}) : Promise.reject(/* @__PURE__ */ Error("Can not call outcome when mode is not evaluate")), S = (e, t) => new Promise((n) => {
+	let { mode: r, role: i } = t || {};
+	if (r !== "evaluate" && i === "instructor") {
+		let { correctResponse: t } = e;
+		n({
+			answers: t,
+			id: 1
+		});
+	} else return n(null);
+}), C = (e) => (e || "").replaceAll(/<[^>]*>/g, ""), w = (e) => (e || "").replace(/(<(?!img|iframe|source)([^>]+)>)/gi, ""), T = (t = {}, i = {}) => {
+	let { categories: a, choices: o, correctResponse: s, maxAnswerChoices: c } = t, { minChoices: l = 1, minCategories: u = 1, maxCategories: d = 12, maxLengthPerChoice: f = 300, maxLengthPerCategory: p = 150 } = i, m = [...o || []].reverse(), h = {}, g = {}, _ = {};
+	[
+		"teacherInstructions",
+		"prompt",
+		"rationale"
+	].forEach((e) => {
+		i[e]?.required && !w(t[e]) && (h[e] = "This field is required.");
+	}), (a || []).forEach((e) => {
+		let { id: t, label: n } = e;
+		C(n).length > p && (_[t] = `Category labels should be no more than ${p} characters long.`);
+	}), (m || []).forEach((e, t) => {
+		let { id: n, content: r } = e;
+		C(r).length > f && (g[n] = `Tokens should be no more than ${f} characters long.`), w(r) ? m.slice(t + 1).some((e) => e.content === r) && (g[n] = "Tokens content should be unique.") : g[n] = "Tokens should not be empty.";
+	});
+	let v = (a || []).length, y = (o || []).length;
+	if (v > d ? h.categoriesError = `No more than ${d} categories should be defined.` : v < u && (h.categoriesError = `There should be at least ${u} category defined.`), y < l ? h.choicesError = `There should be at least ${l} choices defined.` : y > c && (h.choicesError = `No more than ${c} choices should be defined.`), y && v) {
+		let e = !1;
+		(s || []).forEach((t) => {
+			let { choices: n = [], alternateResponses: r = [] } = t;
+			n.length ? e = !0 : r.forEach((t) => {
+				(t || []).length && (e = !0);
+			});
+		});
+		let t = -1, i = "";
+		(s || []).forEach((e) => {
+			let { choices: a = [], alternateResponses: o = [], category: s } = e;
+			t === -1 && (t = r(a, o), t === -1 && (t = n(o)), i = s);
+		}), t > -1 && (h.duplicateAlternate = {
+			index: t,
+			category: i
+		}), e || (h.associationError = "At least one token should be assigned to at least one category.");
+	}
+	return e(g) || (h.choicesErrors = g), e(_) || (h.categoriesErrors = _), h;
+};
+//#endregion
+export { S as createCorrectResponseSession, _ as createDefaultModel, g as getCorrectness, b as getLogTrace, p as getPartialScore, h as getTotalScore, y as model, v as normalize, x as outcome, o as score, T as validate };

package/dist/controller/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @synced-from pie-elements/packages/categorize/controller/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 multiplePlacements: {
+    enabled: string;
+    disabled: string;
+    perChoice: string;
+};
+export declare const isCorrectResponseDuplicated: (choices: any, alternate: any) => any;
+export declare const isAlternateDuplicated: (alternate: any) => number;
+export declare const getCompleteResponseDetails: (correctResponse: any, alternates: any, allChoices: any) => {
+    responseAreasToBeFilled: any;
+    possibleResponses: any[];
+    hasUnplacedChoices: boolean;
+};

package/dist/controller/utils.js

@@ -0,0 +1,35 @@
+//#region src/controller/utils.ts
+var e = {
+	enabled: "Yes",
+	disabled: "No",
+	perChoice: "Set Per Choice"
+}, t = (e, t) => {
+	if (e.length < 1 || t.length < 1) return -1;
+	let n = JSON.stringify(e.sort());
+	return t.reduce((e, t) => t.length > 0 ? [...e, JSON.stringify(t.sort())] : e, []).findIndex((e) => e.length && e === n);
+}, n = (e) => {
+	if (e.length <= 1) return -1;
+	let t = /* @__PURE__ */ new Set(), n = e.reduce((e, t) => t.length > 0 ? [...e, JSON.stringify(t.sort())] : e, []);
+	for (let e = 0; e < n.length; e++) {
+		if (t.has(n[e]) && n[e]) return e;
+		t.add(n[e]);
+	}
+	return -1;
+}, r = (e, t, n) => {
+	let r = e.map((e) => e.choices), i = [r.flat()], a = r.filter((e) => e.length).length;
+	if (t.length) {
+		let e = t[0]?.length || 0;
+		[...Array(e).keys()].forEach((e) => {
+			let n = t.map((t) => t[e]), r = n.filter((e) => e?.length).length;
+			i.push(n.flat()), r < a && (a = r);
+		});
+	}
+	let o = i.some((e) => !n.every((t) => e.includes(t?.id)));
+	return {
+		responseAreasToBeFilled: a,
+		possibleResponses: i,
+		hasUnplacedChoices: o
+	};
+};
+//#endregion
+export { r as getCompleteResponseDetails, n as isAlternateDuplicated, t as isCorrectResponseDuplicated, e as multiplePlacements };

package/dist/delivery/categorize/categories.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @synced-from pie-elements/packages/categorize/src/categorize/categories.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';
+import { CategoryType } from './category.js';
+export { CategoryType };
+export declare class Categories extends React.Component {
+    static propTypes: {
+        categories: PropTypes.Requireable<(PropTypes.InferProps<{
+            id: PropTypes.Validator<string>;
+            categoryId: PropTypes.Requireable<string>;
+        }> | null | undefined)[]>;
+        model: PropTypes.Requireable<PropTypes.InferProps<{
+            categoriesPerRow: PropTypes.Requireable<number>;
+        }>>;
+        disabled: PropTypes.Requireable<boolean>;
+        onDropChoice: PropTypes.Validator<(...args: any[]) => any>;
+        onRemoveChoice: PropTypes.Validator<(...args: any[]) => any>;
+        rowLabels: PropTypes.Requireable<any[]>;
+    };
+    static defaultProps: {
+        model: {
+            categoriesPerRow: number;
+        };
+    };
+    render(): React.JSX.Element;
+}
+export default Categories;

package/dist/delivery/categorize/categories.js

@@ -0,0 +1,66 @@
+import e from "./grid-content.js";
+import t, { CategoryType as n } from "./category.js";
+import r from "react";
+import { color as i } from "@pie-lib/render-ui";
+import a from "prop-types";
+import { styled as o } from "@mui/material/styles";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+//#region src/delivery/categorize/categories.tsx
+var l = class extends r.Component {
+	static propTypes = {
+		categories: a.arrayOf(a.shape(n)),
+		model: a.shape({ categoriesPerRow: a.number }),
+		disabled: a.bool,
+		onDropChoice: a.func.isRequired,
+		onRemoveChoice: a.func.isRequired,
+		rowLabels: a.array
+	};
+	static defaultProps = { model: { categoriesPerRow: 1 } };
+	render() {
+		let { categories: n, model: r, disabled: i, onDropChoice: a, onRemoveChoice: o, rowLabels: l } = this.props, { categoriesPerRow: p, minRowHeight: m } = r, h = [], g = n || [];
+		for (let e = 0; e < g.length; e += p) h.push(g.slice(e, e + p));
+		let _ = (e) => {
+			let t = !1;
+			return (e || []).forEach((e) => {
+				typeof e == "string" && e.trim() !== "" && e.trim() !== "<div></div>" && (t = !0);
+			}), t;
+		};
+		return /* @__PURE__ */ s(e, {
+			columns: p,
+			rows: Math.ceil(n.length / p) * 2,
+			extraStyle: { flex: 1 },
+			children: h.map((e, n) => {
+				let r = [];
+				return e.forEach((e, p) => {
+					r.push(/* @__PURE__ */ c("div", {
+						style: { display: "flex" },
+						children: [p === 0 && _(l) ? /* @__PURE__ */ s(d, { dangerouslySetInnerHTML: { __html: l[n] || "" } }, n) : null, /* @__PURE__ */ c(f, { children: [/* @__PURE__ */ s(u, { dangerouslySetInnerHTML: { __html: e.label } }, `category-label-${n}-${p}`), /* @__PURE__ */ s(t, {
+							minRowHeight: m,
+							onDropChoice: (t) => a(e.id, t),
+							onRemoveChoice: o,
+							disabled: i,
+							...e
+						}, `category-element-${n}-${p}`)] })]
+					}));
+				}), r = r.concat(Array(p - e.length).fill(/* @__PURE__ */ s("div", {})).map((e, t) => /* @__PURE__ */ s("div", {}, `fill-space-final-${t}`))), r;
+			})
+		});
+	}
+}, u = o("div")(({ theme: e }) => ({
+	color: i.text(),
+	backgroundColor: i.background(),
+	textAlign: "center",
+	paddingTop: e.spacing(1)
+})), d = o("div")({
+	alignItems: "center",
+	display: "flex",
+	justifyContent: "center",
+	flex: .5,
+	marginRight: "12px"
+}), f = o("div")({
+	display: "flex",
+	flex: "2",
+	flexDirection: "column"
+});
+//#endregion
+export { l as default };

package/dist/delivery/categorize/category.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @synced-from pie-elements/packages/categorize/src/categorize/category.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 const CategoryType: {
+    id: PropTypes.Validator<string>;
+    categoryId: PropTypes.Requireable<string>;
+};
+export declare class Category extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        onDropChoice: PropTypes.Requireable<(...args: any[]) => any>;
+        onRemoveChoice: PropTypes.Requireable<(...args: any[]) => any>;
+        minRowHeight: PropTypes.Requireable<string>;
+        id: PropTypes.Validator<string>;
+        categoryId: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {};
+    render(): React.JSX.Element;
+}
+export default Category;

package/dist/delivery/categorize/category.js

@@ -0,0 +1,48 @@
+import e from "./choice.js";
+import t from "./droppable-placeholder.js";
+import n from "react";
+import r from "prop-types";
+import { styled as i } from "@mui/material/styles";
+import { jsx as a } from "react/jsx-runtime";
+//#region src/delivery/categorize/category.tsx
+var o = {
+	id: r.string.isRequired,
+	categoryId: r.string
+}, s = class extends n.Component {
+	static propTypes = {
+		...o,
+		className: r.string,
+		disabled: r.bool,
+		onDropChoice: r.func,
+		onRemoveChoice: r.func,
+		minRowHeight: r.string
+	};
+	static defaultProps = {};
+	render() {
+		let { className: n, choices: r = [], disabled: i, onDropChoice: o, onRemoveChoice: s, id: l, correct: u, minRowHeight: d } = this.props;
+		return /* @__PURE__ */ a(c, {
+			className: n,
+			id: l,
+			children: /* @__PURE__ */ a(t, {
+				id: l,
+				onDropChoice: o,
+				disabled: i,
+				correct: u,
+				minRowHeight: d,
+				children: r.map((t, n) => /* @__PURE__ */ a(e, {
+					onRemoveChoice: s,
+					disabled: i,
+					choiceIndex: n,
+					categoryId: l,
+					...t
+				}, n))
+			})
+		});
+	}
+}, c = i("div")(({ theme: e }) => ({
+	display: "flex",
+	flexDirection: "column",
+	flex: 2
+}));
+//#endregion
+export { o as CategoryType, s as default };

package/dist/delivery/categorize/choice.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @synced-from pie-elements/packages/categorize/src/categorize/choice.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 const ChoiceType: {
+    content: PropTypes.Validator<string>;
+    id: PropTypes.Requireable<string>;
+};
+export declare class Layout extends React.Component {
+    static propTypes: {
+        disabled: PropTypes.Requireable<boolean>;
+        correct: PropTypes.Requireable<boolean>;
+        isDragging: PropTypes.Requireable<boolean>;
+        content: PropTypes.Validator<string>;
+        id: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {};
+    render(): React.JSX.Element;
+}
+declare const _default: (props: any) => React.JSX.Element;
+export default _default;