@pie-element/placement-ordering 14.1.1 → 14.1.2-next.0

package/dist/controller/defaults.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @synced-from pie-elements/packages/placement-ordering/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: {
+    choiceLabel: string;
+    choiceLabelEnabled: boolean;
+    choices: never[];
+    correctResponse: never[];
+    feedbackEnabled: boolean;
+    numberedGuides: boolean;
+    orientation: string;
+    partialScoring: boolean;
+    placementArea: boolean;
+    prompt: string;
+    promptEnabled: boolean;
+    rationale: string;
+    rationaleEnabled: boolean;
+    removeTilesAfterPlacing: boolean;
+    scoringType: string;
+    studentInstructionsEnabled: boolean;
+    targetLabel: string;
+    teacherInstructions: string;
+    teacherInstructionsEnabled: boolean;
+    toolbarEditorPosition: string;
+};
+export default _default;

package/dist/controller/defaults.js

@@ -0,0 +1,25 @@
+//#region src/controller/defaults.ts
+var e = {
+	choiceLabel: "",
+	choiceLabelEnabled: !0,
+	choices: [],
+	correctResponse: [],
+	feedbackEnabled: !1,
+	numberedGuides: !1,
+	orientation: "vertical",
+	partialScoring: !0,
+	placementArea: !1,
+	prompt: "",
+	promptEnabled: !0,
+	rationale: "",
+	rationaleEnabled: !0,
+	removeTilesAfterPlacing: !0,
+	scoringType: "auto",
+	studentInstructionsEnabled: !0,
+	targetLabel: "",
+	teacherInstructions: "",
+	teacherInstructionsEnabled: !0,
+	toolbarEditorPosition: "bottom"
+};
+//#endregion
+export { e as default };

package/dist/controller/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @synced-from pie-elements/packages/placement-ordering/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.
+ */
+export declare const questionError: () => Error;
+/**
+ * Generates detailed trace log for placement-ordering scoring evaluation
+ * @param {Object} question - the question model
+ * @param {Object} session - the student session
+ * @param {Object} env - the environment
+ * @returns {Array<string>} traceLog
+ */
+export declare const getLogTrace: (question: any, session: any, env: any) => string[];
+export declare function outcome(question: any, session: any, env: any): Promise<unknown>;
+export declare function createDefaultModel(model?: {}): Promise<unknown>;
+export declare const normalize: (question: any) => any;
+/**
+ *
+ * @param {*} question
+ * @param {*} session
+ * @param {*} env
+ */
+export declare function model(question: any, session: any, env: any): Promise<{}>;
+export declare const createCorrectResponseSession: (question: any, env: any) => Promise<unknown>;
+export declare const validate: (model?: {}, config?: {}) => {};

package/dist/controller/index.js

@@ -0,0 +1,128 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isArray.js";
+import t from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/every.js";
+import n from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/map.js";
+import r from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isEmpty.js";
+import i from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isEqual.js";
+import a from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/reduce.js";
+import { flattenCorrect as o, getAllCorrectResponses as s, score as c } from "./scoring.js";
+import l from "./defaults.js";
+import u from "debug";
+import d from "@pie-lib/translator";
+import { getFeedbackForCorrectness as f } from "@pie-element/shared-feedback";
+import { partialScoring as p } from "@pie-element/shared-controller-utils";
+//#region src/controller/index.ts
+var m = u("@pie-element:placement-ordering:controller"), { translator: h } = d, g = () => /* @__PURE__ */ Error("Question is missing required array: correctResponse"), _ = (e, t, n) => {
+	let r = [], a = t?.value || [];
+	e?.correctResponse;
+	let o = e?.placementArea === !0;
+	if (!a.length) return o ? r.push("Student did not place any tiles in the target area.") : r.push("Student did not reorder any tiles."), r.push("Final score: 0."), r;
+	let l = s(e), u = {
+		score: 0,
+		response: []
+	};
+	l.forEach((e) => {
+		let t = 0;
+		a.forEach((n, r) => {
+			e[r] === n && t++;
+		}), t > u.score && (u = {
+			score: t,
+			response: e
+		});
+	});
+	let d = u.score, f = a.length - d;
+	d > 0 && r.push(`${d} tile(s) placed in the correct order.`), f > 0 && r.push(`${f} tile(s) placed in an incorrect order.`), l.some((e) => i(e, a));
+	let m = p.enabled(e, n || {});
+	m ? (r.push("Score calculated using partial scoring."), r.push("Each tile placed in the correct position contributes to the score.")) : (r.push("Score calculated using all-or-nothing scoring."), o ? r.push("Student must place all tiles in the correct positions within the target area to receive full credit.") : r.push("Student must arrange all tiles in the correct order to receive full credit."));
+	let h = c(e, t), g = m ? h : +(h === 1);
+	return r.push(`Final score: ${g}.`), r;
+};
+function v(e, t, n) {
+	return new Promise((i, a) => {
+		if (!t || r(t)) {
+			i({
+				score: 0,
+				empty: !0,
+				logTrace: ["Student did not interact with the placement-ordering item."]
+			});
+			return;
+		}
+		if (!e || !e.correctResponse || r(e.correctResponse)) a(g());
+		else try {
+			let r = c(e, t);
+			i({
+				score: p.enabled(e, n || {}) ? r : +(r === 1),
+				logTrace: _(e, t, n)
+			});
+		} catch (e) {
+			a(e);
+		}
+	});
+}
+function y(e = {}) {
+	return new Promise((t) => {
+		t({
+			...l,
+			...e
+		});
+	});
+}
+var b = (e) => ({
+	...l,
+	rationaleEnabled: !0,
+	feedbackEnabled: !1,
+	promptEnabled: !0,
+	teacherInstructionsEnabled: !0,
+	studentInstructionsEnabled: !0,
+	...e
+});
+async function x(r, l, u) {
+	let d = b(r), g = {};
+	if (r.alternateResponses && t(r.alternateResponses, e) && (m("Deprecated structure of alternateResponses is in use"), console.error("Deprecated structure of alternateResponses is in use")), g.env = u, g.extraCSSRules = d.extraCSSRules, g.outcomes = [], g.completeLength = (d.correctResponse || []).length, g.choices = (d.choices || []).filter((e) => e.label), g.note = d.note, g.showNote = d.alternateResponses && d.alternateResponses.length > 0, g.language = d.language, m("[model] removing tileSize for the moment."), g.prompt = d.promptEnabled ? d.prompt : null, g.config = {
+		orientation: d.orientation || "vertical",
+		includeTargets: d.placementArea,
+		choiceLabelEnabled: d.choiceLabelEnabled,
+		targetLabel: d.targetLabel,
+		choiceLabel: d.choiceLabel,
+		showOrdering: d.numberedGuides,
+		allowSameChoiceInTargets: !d.removeTilesAfterPlacing
+	}, g.disabled = u.mode !== "gather", g.note ||= h.t("common:commonCorrectAnswerWithAlternates", { lng: d.language }), u.role === "instructor" && (u.mode === "view" || u.mode === "evaluate") ? (g.rationale = d.rationaleEnabled ? d.rationale : null, g.teacherInstructions = d.teacherInstructionsEnabled ? d.teacherInstructions : null) : (g.rationale = null, g.teacherInstructions = null), u.mode === "evaluate") {
+		let e = l && l.value || [], t = s(d), m = t.reduce((t, n) => {
+			let r = a(e, (e, t, r) => e + (Array.isArray(n) && n[r] === t ? 1 : 0), 0);
+			return r > t.score ? {
+				arr: n,
+				score: r
+			} : t;
+		}, {
+			arr: [],
+			score: 0
+		});
+		g.outcomes = n(e, (e, t) => ({
+			id: e,
+			outcome: m.arr[t] === e ? "correct" : "incorrect"
+		}));
+		let h = t.some((t) => i(t, e)), _ = c(r, l), v = _ === 1, y = !v && p.enabled(d, u || {}) && _ !== 0;
+		return g.correctness = v ? "correct" : y ? "partial" : "incorrect", h || (g.correctResponse = o(d)), d.feedback || (d.feedbackEnabled = !1), g.feedback = d.feedbackEnabled ? await f(g.correctness, d.feedback) : void 0, g;
+	} else return g;
+}
+var S = (e, t) => new Promise((n) => {
+	t.mode !== "evaluate" && t.role === "instructor" ? n({
+		id: "1",
+		value: o(e)
+	}) : n(null);
+}), C = (e) => (e || "").replace(/(<(?!img|iframe|source)([^>]+)>)/gi, ""), w = (e = {}, t = {}) => {
+	let { choices: n, correctResponse: a } = e, o = {};
+	[
+		"teacherInstructions",
+		"prompt",
+		"rationale"
+	].forEach((n) => {
+		t[n]?.required && !C(e[n]) && (o[n] = "This field is required.");
+	});
+	let s = [...n || []].reverse(), c = {};
+	return s.forEach((e, t) => {
+		let { id: n, label: r } = e;
+		C(r) ? s.slice(t + 1).some((e) => e.label === r) && (c[n] = "Content should be unique.") : c[n] = "Content should not be empty.";
+	}), i((n || []).map((e) => e.id), (a || []).map((e) => e.id || e)) && (o.orderError = "The correct ordering should not be identical to the initial ordering."), r(c) || (o.choicesErrors = c), o;
+};
+//#endregion
+export { S as createCorrectResponseSession, y as createDefaultModel, _ as getLogTrace, x as model, b as normalize, v as outcome, g as questionError, w as validate };

package/dist/controller/scoring.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @synced-from pie-elements/packages/placement-ordering/controller/src/scoring.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 illegalArgumentError: (answer: any) => Error;
+export declare const pairwiseCombinationScore: (correct: any, answer: any, opts: any) => number;
+/**
+ * Flattens the correctResponse into an array of ordered identifiers representing the
+ * correct response.
+ */
+export declare const flattenCorrect: (question: any) => any;
+/**
+ * Returns all correct responses for this question
+ * @param question - array
+ */
+export declare const getAllCorrectResponses: (question: any) => any[];
+/**
+ * Returns the score for a session. If weighted scoring is present in the correctResponse
+ * field for the question, this will be used. If partial scoring is present in the question
+ * model, this will be used. Otherwise the default scoring mechanism (0 for any incorrect, 1
+ * for all correct) will be used.
+ */
+export declare const score: (question: any, session: any) => number;

package/dist/controller/scoring.js

@@ -0,0 +1,32 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/differenceWith.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/uniq.js";
+import r from "debug";
+import { combination as i } from "js-combinatorics";
+//#region src/controller/scoring.ts
+var a = r("pie-elements:placement-ordering:controller"), o = (e) => /* @__PURE__ */ Error(`Cant score answer: ${e} it has duplicates and allowDuplicates is false`), s = (r, s, c) => {
+	if (c = {
+		allowDuplicates: !1,
+		orderMustBeComplete: !1,
+		...c
+	}, !c.allowDuplicates && !t(n(r), r)) throw o(s);
+	if (c.allowDuplicates === !1 && s.length !== n(s).length) return 0;
+	if (s = c.allowDuplicates === !1 ? n(s) : s, a("answer:", s), !Array.isArray(r) || r.length === 0) throw Error("correct must be non empty an array");
+	if (r.length === 1) return +!!t(r, s);
+	if (!Array.isArray(s) || s.length < 2 || s.length > r.length || r.length !== s.length && c.orderMustBeComplete) return 0;
+	let l = i(r, 2).toArray(), u = i(s, 2).toArray(), d = e(u, l, t), f = l.length - u.length, p = l.length, m = ((p - d.length - f) / p).toFixed(2);
+	return parseFloat(m);
+}, c = (e) => e.correctResponse ? e.correctResponse.map((e) => e && e.id ? e.id : e) : [], l = (e) => {
+	let t = (e.alternateResponses || []).map((e) => Array.isArray(e) ? e : e.response).filter((e) => e !== void 0);
+	return [c(e), ...t];
+}, u = (e, t) => {
+	let { value: n } = t || {};
+	if (!n) return 0;
+	let r = l(e), i = (e.configure && e.configure.removeTilesAfterPlacing) !== !1, a = 0;
+	return r.forEach((e) => {
+		let t = s(e, n, { allowDuplicates: i });
+		t >= a && (a = t);
+	}), a;
+};
+//#endregion
+export { c as flattenCorrect, l as getAllCorrectResponses, u as score };

package/dist/delivery/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @synced-from pie-elements/packages/placement-ordering/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.
+ */
+export declare const isValidSession: ({ model, session }: {
+    model: any;
+    session: any;
+}) => any;
+export default class Ordering extends HTMLElement {
+    constructor();
+    _scheduleMathRender: any;
+    _initMathObserver(): void;
+    _disconnectMathObserver(): void;
+    isComplete: (value: any) => any;
+    sessionChange: any;
+    set model(newModel: any);
+    set session(newSession: any);
+    get session(): any;
+    render(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}

package/dist/delivery/index.js

@@ -0,0 +1,70 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/compact.js";
+import t from "./main.js";
+import n from "react";
+import { createRoot as r } from "react-dom/client";
+import i from "debug";
+import { renderMath as a } from "@pie-element/shared-math-rendering-mathjax";
+import { SessionChangedEvent as o } from "@pie-element/shared-player-events";
+//#region src/delivery/index.ts
+var s = i("pie-elements:placement-ordering"), c = ({ model: t, session: n }) => {
+	let { config: r } = t, i = (n && e(n.value) || []).length === t.choices.length;
+	return r.includeTargets || i;
+}, l = class extends HTMLElement {
+	constructor() {
+		super(), this._root = null, this._mathObserver = null, this._mathRenderPending = !1;
+	}
+	_scheduleMathRender = () => {
+		this._mathRenderPending || (this._mathRenderPending = !0, requestAnimationFrame(() => {
+			this._mathObserver && this._mathObserver.disconnect(), a(this), this._mathRenderPending = !1, setTimeout(() => {
+				this._mathObserver && this._mathObserver.observe(this, {
+					childList: !0,
+					subtree: !0
+				});
+			}, 50);
+		}));
+	};
+	_initMathObserver() {
+		this._mathObserver || (this._mathObserver = new MutationObserver(this._scheduleMathRender), this._mathObserver.observe(this, {
+			childList: !0,
+			subtree: !0
+		}));
+	}
+	_disconnectMathObserver() {
+		this._mathObserver &&= (this._mathObserver.disconnect(), null);
+	}
+	isComplete = (t) => t && e(t).length === this._model.completeLength;
+	sessionChange = (e) => {
+		this._session.value = e.value, this.render(), this.dispatchEvent(new o(this.tagName.toLowerCase(), this._session && this.isComplete(this._session.value)));
+	};
+	set model(e) {
+		this._model = e, this.render(), this.dispatchEvent(new CustomEvent("model-set", {
+			bubbles: !0,
+			detail: { complete: !1 }
+		}));
+	}
+	set session(e) {
+		this._session = e, this.render();
+	}
+	get session() {
+		return this._session;
+	}
+	render() {
+		if (this._model && this._session) {
+			s("[render] session: ", this._session.value), s("[render] model: ", this._model), this._initMathObserver();
+			let e = n.createElement(t, {
+				model: this._model,
+				session: this._session,
+				onSessionChange: this.sessionChange
+			});
+			this._root ||= r(this), this._root.render(e);
+		}
+	}
+	connectedCallback() {
+		this._initMathObserver();
+	}
+	disconnectedCallback() {
+		this._disconnectMathObserver(), this._root && this._root.unmount();
+	}
+};
+//#endregion
+export { l as default, c as isValidSession };

package/dist/delivery/main.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @synced-from pie-elements/packages/placement-ordering/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';
+declare class Main extends React.Component {
+    static propTypes: {
+        model: PropTypes.Validator<object>;
+        session: PropTypes.Requireable<object>;
+        onSessionChange: PropTypes.Validator<(...args: any[]) => any>;
+    };
+    render(): React.JSX.Element;
+}
+export default Main;

package/dist/delivery/main.js

@@ -0,0 +1,22 @@
+import e from "./placement-ordering.js";
+import t from "react";
+import n from "prop-types";
+import { jsx as r } from "react/jsx-runtime";
+//#region src/delivery/main.tsx
+var i = class extends t.Component {
+	static propTypes = {
+		model: n.object.isRequired,
+		session: n.oneOfType([n.array.isRequired, n.object.isRequired]),
+		onSessionChange: n.func.isRequired
+	};
+	render() {
+		let { model: t, session: n, onSessionChange: i } = this.props;
+		return /* @__PURE__ */ r(e, {
+			model: t,
+			session: n,
+			onSessionChange: i
+		});
+	}
+};
+//#endregion
+export { i as default };

package/dist/delivery/ordering.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @synced-from pie-elements/packages/placement-ordering/src/ordering.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 push: (arr: any, fromIndex: any, toIndex: any) => any[];
+export declare const swap: (arr: any, fromIndex: any, toIndex: any) => any;
+export declare function buildState(choices: any, response: any, outcomes: any, opts: any): {
+    choices: any;
+    response: any;
+    opts: any;
+    outcomes: any;
+    tiles: any;
+};
+export declare function reducer(action: any, state: any): any;

package/dist/delivery/ordering.js

@@ -0,0 +1,96 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/assign.js";
+import t from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/cloneDeep.js";
+import n from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/map.js";
+import r from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/isEmpty.js";
+import i from "debug";
+//#region src/delivery/ordering.ts
+var a = i("pie-elements:placement-ordering:ordering"), o = (e, t, n) => {
+	let r = e.find((e, n) => n === t), i = e.filter((e, n) => n !== t);
+	return [
+		...i.slice(0, n),
+		r,
+		...i.slice(n)
+	];
+}, s = (e, n, r) => {
+	if (a("[swap]", e, n, r), !e || e.length <= 1 || n === void 0 || r === void 0) throw Error(`swap requires a non-empty array, fromIndex, toIndex: ${e}, ${n} ${r}`);
+	let i = t(e), o = e[r];
+	return i[r] = i[n], i[n] = o, i;
+};
+function c(e, n) {
+	let r = t(e.response);
+	if (r[n.index] === n.id) r[n.index] = void 0;
+	else throw Error(`Tried to remove from index: ${n.index}, but the id doesn't match: array: ${r}, target: ${n.id}`);
+	return r;
+}
+function l(e, n, r) {
+	let { response: i, opts: c } = e, l = t(i);
+	if (c.includeTargets) return n.type === "choice" && r.type === "target" ? (l[r.index] = n.id, l) : n.type === "target" && r.type === "choice" ? (l[n.index] = void 0, l) : n.type === "target" && r.type === "target" ? s(i, n.index, r.index) : (a("do nothing to the response"), i);
+	{
+		let t = e.response.findIndex((e) => e !== void 0 && e === n.id), i = e.response.findIndex((e) => e !== void 0 && e === r.id);
+		return a("fromIndex: ", t, "toIndex:", i), o(e.response, t, i);
+	}
+}
+function u(e, t, n, r) {
+	if (r.includeTargets) {
+		let i = [];
+		for (let r = 0; r < t.length; r++) {
+			let a = t[r], o = e.find((e) => a != null && e.id === a), s = n[r], c = Object.assign({
+				type: "target",
+				index: r,
+				empty: o === void 0
+			}, o, s, { draggable: o !== void 0 });
+			i.push(c);
+		}
+		return e.map((e) => t.indexOf(e.id) !== -1 && !r.allowSameChoiceInTargets ? {
+			type: "choice",
+			empty: !0,
+			droppable: !0,
+			draggable: !1
+		} : Object.assign({}, e, {
+			type: "choice",
+			droppable: !1,
+			draggable: !0
+		})).concat(i);
+	} else return t.reduce((t, r, i) => {
+		let a = Object.assign({
+			type: "empty",
+			draggable: !1,
+			droppable: !0
+		}, e.find((e) => e.id === r), n[i]), o = Object.assign({
+			type: "choice",
+			draggable: !0,
+			droppable: !0
+		}, e.find((e) => e.id === r), n[i]);
+		return i === 0 && t.push(a), t.push(o, a), t;
+	}, []);
+}
+function d(t, i, a, o) {
+	return o = e({ includeTargets: !0 }, o), a ||= [], i = !i || r(i) ? o.includeTargets ? Array(t.length) : n(t, (e) => e.id) : i, {
+		choices: t,
+		response: i,
+		opts: o,
+		outcomes: a,
+		tiles: u(t, i, a, o)
+	};
+}
+function f(e, t) {
+	switch (e.type) {
+		case "move": {
+			let { from: n, to: r } = e, i = l(t, n, r), a = u(t.choices, i, t.outcomes, t.opts);
+			return Object.assign({}, t, {
+				response: i,
+				tiles: a
+			});
+		}
+		case "remove": {
+			let { target: n } = e, r = c(t, n), i = u(t.choices, r, t.outcomes, t.opts);
+			return Object.assign({}, t, {
+				response: r,
+				tiles: i
+			});
+		}
+	}
+	return t;
+}
+//#endregion
+export { d as buildState, f as reducer };

package/dist/delivery/placement-ordering.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @synced-from pie-elements/packages/placement-ordering/src/placement-ordering.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 PlacementOrdering extends React.Component {
+    static propTypes: {
+        onSessionChange: PropTypes.Validator<(...args: any[]) => any>;
+        model: PropTypes.Validator<object>;
+        session: PropTypes.Requireable<object>;
+    };
+    constructor(props: any);
+    toggleCorrect: (showingCorrect: any) => void;
+    componentDidUpdate(): void;
+    validateSession: any;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    onDropChoice: any;
+    onRemoveChoice: any;
+    createOrdering: any;
+    onDragEnd: any;
+    render(): React.JSX.Element;
+}
+export default PlacementOrdering;