@lernapps/app-templates 0.0.1 → 0.1.1

package/dist/result-D_mmCVwN.mjs

@@ -0,0 +1,180 @@
+import { x as rightEntries } from "./render-GS1Htlu8.mjs";
+import { w as message } from "./assessment-Dy359O1O.mjs";
+// runtime/explainer/result.ts
+const key = (id, n) => n === void 0 ? id : `${id}=${n}`;
+/**
+* What the learner did on this page, by task (an exercise and its task number), kept in memory only: the page stores
+* nothing, so the session is this visit of the page, which a tutor's link opens in a tab of its own.
+*/
+var Progress = class {
+	#tasks = /* @__PURE__ */ new Map();
+	#listeners = [];
+	#last;
+	/** Calls `listener` with the exercise's id whenever the state of one of its tasks changes. */
+	listen(listener) {
+		this.#listeners.push(listener);
+	}
+	#set(id, n, state) {
+		this.#tasks.set(key(id, n), state);
+		for (const listener of this.#listeners) listener(id);
+	}
+	/**
+	* A complete answer to the task number `n` of the exercise `id` (none for an exercise without numbers): the input as
+	* text, and the message the app showed for a wrong one, word for word.
+	*/
+	answered(id, n, right, input, message) {
+		this.#last = id;
+		const state = this.state(id, n);
+		if (state.rightAt !== void 0 || state.revealed) return;
+		const attempts = state.attempts + 1;
+		const { input: _input, message: _message, ...rest } = state;
+		this.#set(id, n, {
+			...rest,
+			attempts,
+			...right ? { rightAt: attempts } : {},
+			...right || input === void 0 ? {} : { input },
+			...right || message === void 0 || message === "" ? {} : { message }
+		});
+	}
+	/**
+	* The open task `id` as the learner compared it: `ticked` of `total` points, the `missed` ones named (P2, P4), the
+	* answer as text (or that it is a photo). `attempt`: a new comparing, which counts as a try; a changed tick changes
+	* the same try. Its model answer shows once compared.
+	*/
+	compared(id, ticked, total, missed, input, attempt = true) {
+		this.#last = id;
+		const state = this.state(id, void 0);
+		const attempts = attempt ? state.attempts + 1 : Math.max(state.attempts, 1);
+		const { points: _points, input: _input, rightAt: _rightAt, ...rest } = state;
+		this.#set(id, void 0, {
+			...rest,
+			attempts,
+			revealed: true,
+			...ticked === total ? { rightAt: attempts } : {
+				points: {
+					ticked,
+					total,
+					missed
+				},
+				input
+			}
+		});
+	}
+	/** The learner opened the hint of the task. */
+	hinted(id, n) {
+		const state = this.state(id, n);
+		if (state.hint === true) return;
+		this.#set(id, n, {
+			...state,
+			hint: true
+		});
+	}
+	/** The solution of the task shows ("Lösung"; also after the right answer, which then stays right). */
+	revealed(id, n) {
+		this.#last = id;
+		const state = this.state(id, n);
+		if (state.rightAt !== void 0) return;
+		this.#set(id, n, {
+			...state,
+			revealed: true
+		});
+	}
+	/** How far the learner got with the task. */
+	state(id, n) {
+		return this.#tasks.get(key(id, n)) ?? {
+			attempts: 0,
+			revealed: false
+		};
+	}
+	/** The exercise the learner answered last, if any. */
+	get last() {
+		return this.#last;
+	}
+	/** Each task the learner answered or looked up in this session, in the order they first did. */
+	tasks() {
+		return [...this.#tasks.entries()].filter(([, state]) => state.attempts > 0 || state.revealed).map(([key, state]) => {
+			const [id = "", n] = key.split("=");
+			return {
+				id,
+				...n === void 0 ? {} : { number: Number(n) },
+				state
+			};
+		});
+	}
+	/** The count of the session. */
+	session() {
+		const states = [...this.#tasks.values()].filter((state) => state.attempts > 0 || state.revealed);
+		return {
+			right: states.filter((state) => state.rightAt !== void 0).length,
+			total: states.length
+		};
+	}
+};
+/** How far the learner got with a task, in `lang`: "richtig im 2. Versuch", "noch nicht gelöst (1 Versuch, …)". */
+function statusOf(state, lang) {
+	if (state.rightAt !== void 0) return message(lang, "resultRight", { n: String(state.rightAt) });
+	if (state.points !== void 0) {
+		const partly = message(lang, "resultPartly", {
+			n: String(state.points.ticked),
+			total: String(state.points.total),
+			missed: state.points.missed
+		});
+		return state.input === void 0 ? partly : `${partly}, ${message(lang, "resultAnswer", { input: state.input })}`;
+	}
+	const status = message(lang, state.revealed ? "resultSolution" : "resultOpen");
+	if (state.attempts === 0) return status;
+	return `${status} (${state.attempts === 1 ? message(lang, "resultTry") : message(lang, "resultTries", { n: String(state.attempts) })}${state.input === void 0 ? "" : `, ${message(lang, "resultInput", { input: state.input })}`})`;
+}
+/**
+* What "Zurück zum Tutor" at the top or the end of a page copies, in `lang`: the page's tutor page with the page's
+* task numbers, then a line for each task the learner answered or looked up in this session (the exercise, its task
+* number, how far the learner got, the last wrong input and the app's message for it, word for word), then the count of
+* the session; a tutor loads the tutor page and coaches on exactly these tasks.
+*/
+function sessionLines(tutor, tasks, session, lang) {
+	if (tasks.length === 0) return message(lang, "sessionNone", { url: tutor });
+	return [
+		message(lang, "sessionIntro", { url: tutor }),
+		...tasks.map((task) => {
+			const said = task.state.rightAt === void 0 && task.state.message !== void 0 ? ` ${message(lang, "stuckMessage", { message: task.state.message.replace(/\s+/g, " ").trim() })}` : "";
+			return `- ${message(lang, "sessionTask", {
+				exercise: task.id,
+				number: task.number === void 0 ? "" : message(lang, "resultNumber", { n: String(task.number) }),
+				status: statusOf(task.state, lang)
+			})}${said}`;
+		}),
+		message(lang, "resultSession", {
+			right: String(session.right),
+			total: String(session.total)
+		})
+	].join("\n");
+}
+/** The result line, two lines in `lang`: the result, and the page's tutor page. */
+function resultLine(line, lang) {
+	return [`${message(lang, "resultLine", {
+		page: line.page,
+		exercise: line.exercise,
+		number: line.number === void 0 ? "" : message(lang, "resultNumber", { n: String(line.number) }),
+		status: statusOf(line.state, lang)
+	})}${line.session.total === 0 ? "" : ` ${message(lang, "resultSession", {
+		right: String(line.session.right),
+		total: String(line.session.total)
+	})}`}`, `${message(lang, "resultTutor")} ${line.tutor}`].join("\n");
+}
+const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+/** The learner's answer to a question as text, in `lang`: the options chosen, the number typed, the order given. */
+function answerShown(question, answer, lang) {
+	const indices = typeof answer === "number" ? [answer] : Array.isArray(answer) ? answer : [];
+	switch (question.type) {
+		case "single-choice":
+		case "multiple-choice": return indices.map((index) => oneLine(question.options[index]?.text ?? "?")).join("; ");
+		case "true-false": return message(lang, answer === true ? "resultTrue" : "resultFalse");
+		case "number": return oneLine(String(answer));
+		case "ordering": return indices.map((place, item) => ({
+			place,
+			item
+		})).filter(({ place }) => place >= 0).sort((a, b) => a.place - b.place).map(({ item }) => oneLine(question.items[item] ?? "?")).join(" → ");
+		case "matching": return question.pairs.map((pair, index) => `${oneLine(pair.left)} → ${oneLine(rightEntries(question)[indices[index] ?? -1] ?? "?")}`).join("; ");
+	}
+}
+export { sessionLines as i, answerShown as n, resultLine as r, Progress as t };

package/dist/tasks-DADUYy52.mjs

@@ -0,0 +1,74 @@
+/** How many seeds the build tries at most to find MAX_TASKS distinct tasks. */
+const SEED_TRIES = 1340;
+/**
+* The seeds of the distinct tasks, in order: seed 1, 2, 3, … kept when `key(seed)` (what the learner sees of its task,
+* language-independent) differs from every kept one's, until `max` are kept or `tries` seeds are tried; a seed whose
+* key is undefined (its task cannot be drawn) is skipped.
+*/
+function distinctSeeds(key, max = 67, tries = SEED_TRIES) {
+	const seen = /* @__PURE__ */ new Set();
+	const seeds = [];
+	for (let seed = 1; seed <= tries && seeds.length < max; seed++) {
+		const found = key(seed);
+		if (found === void 0 || seen.has(found)) continue;
+		seen.add(found);
+		seeds.push(seed);
+	}
+	return seeds;
+}
+/** The task number `n` within 1 to `count`: a number outside wraps around into it (68 of 67 is 1). */
+const taskNumber = (n, count) => ((Math.trunc(n) - 1) % count + count) % count + 1;
+/** The task number after `n`, for "Neue Aufgabe": the next one, from `count` back to 1. */
+const nextTaskNumber = (n, count) => n % count + 1;
+/** A task number to start with when the address names none. */
+const randomTaskNumber = (count) => 1 + Math.floor(Math.random() * count);
+/**
+* Address parameters that are no exercise's: the page's (seed, via) and those of its tutor page, whose address holds
+* the page's task numbers beside them (uebung, abschnitt; position.ts). An exercise id must not be one of them (the
+* build checks).
+*/
+const RESERVED_PARAMS = [
+	"seed",
+	"via",
+	"uebung",
+	"abschnitt"
+];
+/**
+* The task number the address `href` gives the exercise `id`: the parameter named by its id (?<id>=<n>, one per
+* exercise, so that the address holds the task of every exercise of the page), or, as before, ?seed=<n>#<id>.
+*/
+function numberFromAddress(href, id) {
+	const url = new URL(href);
+	const asNumber = (text) => {
+		const n = Number(text);
+		return text !== null && Number.isInteger(n) && n > 0 ? n : void 0;
+	};
+	const own = asNumber(url.searchParams.get(id));
+	if (own !== void 0) return own;
+	return decodeURIComponent(url.hash.slice(1)) === id ? asNumber(url.searchParams.get("seed")) : void 0;
+}
+/**
+* The address `href` with the task number `n` of the exercise `id`: ?…&<id>=<n>, its other parameters and its anchor
+* kept. A ?seed=<n> that named this exercise's task (it is the anchor) becomes the exercise's own parameter.
+*/
+function addressOf(href, id, n) {
+	const url = new URL(href);
+	if (decodeURIComponent(url.hash.slice(1)) === id) url.searchParams.delete("seed");
+	url.searchParams.set(id, String(n));
+	return url.href;
+}
+/** "Neue Aufgabe" as a symbol beside the task number: a circular arrow; the button's label is its name. */
+const NEW_TASK_ICON = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\" focusable=\"false\"><path d=\"M21 12a9 9 0 1 1-2.6-6.4\"/><path d=\"M21 3v6h-6\"/></svg>";
+/** The event an exercise sends on its element once it shows a task: the tutor's help button takes its place again. */
+const SHOWN_EVENT = "explainer-shown";
+/**
+* The events between a self-assessment (assessment-client.ts) and the islands (islands.ts): the self-assessment put
+* its exercises into the page (on the document); it gives an exercise component the task of `seed` (on its element);
+* the component's answer changed, as { correct, partly?, answer?, message?, mistake?, missed? }, with mistake the
+* index of the typical mistake it makes from 0, and missed the indexes of the points of a good answer it lacks, each
+* from 0; or null when it has none: emptied, incomplete, or one its logic cannot read (on its element, bubbling).
+*/
+const ASSESSMENT_UNPACKED_EVENT = "explainer-assessment-unpacked";
+const ASSESSMENT_TASK_EVENT = "explainer-assessment-task";
+const ASSESSMENT_ANSWER_EVENT = "explainer-assessment-answer";
+export { RESERVED_PARAMS as a, addressOf as c, numberFromAddress as d, randomTaskNumber as f, NEW_TASK_ICON as i, distinctSeeds as l, ASSESSMENT_TASK_EVENT as n, SEED_TRIES as o, taskNumber as p, ASSESSMENT_UNPACKED_EVENT as r, SHOWN_EVENT as s, ASSESSMENT_ANSWER_EVENT as t, nextTaskNumber as u };