@lernapps/tooling 0.4.0 → 0.5.1

package/dist/check/rules/competencies-on-map.mjs

@@ -0,0 +1,85 @@
+import { a as strandsOf, i as readExplainer, n as loadMap, r as mapUrl } from "../../explainer-map-DW4XCcY0.mjs";
+// check/rules/competencies-on-map.ts
+const RECAP = /^([a-z0-9]+(?:-[a-z0-9]+)*)\/([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+var competencies_on_map_default = {
+	id: "competencies-on-map",
+	url: "https://lernapps.net/tooling/rules/#competencies-on-map",
+	description: "The strand of an explainer in format 2 is a strand of its subject's learning map, every page's competencies belong to it, and every recap page repeats a competency of the map that the app does not practise.",
+	severity: "warning",
+	run: async ({ project }) => {
+		const explainer = project === void 0 ? void 0 : readExplainer(project);
+		if (explainer === void 0 || explainer.strand === "none") return void 0;
+		const [subject = "", strandId = ""] = explainer.strand.split("/");
+		const url = mapUrl(subject);
+		const loaded = await loadMap(url);
+		if ("failed" in loaded) return [{
+			where: explainer.strandAt,
+			found: `the strand and the competencies could not be checked: ${loaded.failed}`,
+			fix: "Nothing to fix for this here: check again later (lernapps check); the listing checks the ids against the map",
+			severity: "hint"
+		}];
+		const strands = loaded.map.strands;
+		const strandOf = strandsOf(loaded.map);
+		const problems = [];
+		const practised = /* @__PURE__ */ new Map();
+		for (const page of explainer.pages) for (const id of page.competencies) if (!practised.has(id)) practised.set(id, page.where);
+		const strand = strands.find((candidate) => candidate.id === strandId);
+		if (strand === void 0) problems.push({
+			where: explainer.strandAt,
+			found: `the strand ${explainer.strand} is not on the map of ${subject} (its strands: ${strands.map((s) => s.id).join(", ")})`,
+			fix: `Name a strand of ${url} as <subject>/<strand>, or strand: none; a strand the map lacks is proposed to lernapps/apps (map/${subject}.yaml)`
+		});
+		for (const page of explainer.pages) {
+			for (const id of page.competencies) {
+				const of = strandOf.get(id);
+				if (of === void 0) problems.push({
+					where: page.where,
+					found: `the competency ${id} is not on the map of ${subject}`,
+					fix: `Use an id of the strand ${explainer.strand} from ${url}; a competency the map lacks is proposed to lernapps/apps (map/${subject}.yaml), never invented in the app`
+				});
+				else if (strand !== void 0 && of !== strandId) problems.push({
+					where: page.where,
+					found: `the competency ${id} belongs to the strand ${subject}/${of}, not to the app's strand ${explainer.strand}`,
+					fix: `Practise only competencies of ${explainer.strand}; a page of ${subject}/${of} belongs in an app of that strand`
+				});
+			}
+			if (page.recap !== void 0) problems.push(...await recapProblems(page.where, page.recap, {
+				subject,
+				map: loaded.map,
+				url,
+				practised
+			}));
+		}
+		return problems;
+	}
+};
+/** A recap page's `recap`: a competency of a map, of any strand, that the app does not practise on a page of its own. */
+async function recapProblems(where, recap, app) {
+	const { subject, url, practised } = app;
+	const [, recapSubject = "", id = ""] = RECAP.exec(recap) ?? [];
+	if (recapSubject === "") return [{
+		where,
+		found: `the recap ${recap} is not <subject>/<competency>`,
+		fix: `Name the competency the page repeats as <subject>/<competency>, e.g. ${subject}/<id> from ${url}`
+	}];
+	const other = recapSubject === subject ? { map: app.map } : await loadMap(mapUrl(recapSubject));
+	if ("failed" in other) return [{
+		where,
+		found: `the recap ${recap} could not be checked: ${other.failed}`,
+		fix: "Nothing to fix for this here: check again later (lernapps check); the listing checks the recap against the map",
+		severity: "hint"
+	}];
+	if (strandsOf(other.map).get(id) === void 0) return [{
+		where,
+		found: `the recap ${recap} is not on the map of ${recapSubject}`,
+		fix: `Name a competency of ${mapUrl(recapSubject)} that a page of this app requires; a competency the map lacks is proposed to lernapps/apps (map/${recapSubject}.yaml)`
+	}];
+	const page = recapSubject === subject ? practised.get(id) : void 0;
+	if (page !== void 0) return [{
+		where,
+		found: `the recap ${recap} is a competency the app also practises (${page})`,
+		fix: `A competency the app practises needs no recap: remove this recap page, or the competency ${id} from the page that practises it`
+	}];
+	return [];
+}
+export { competencies_on_map_default as default };

package/dist/check/rules/one-competency-per-page.mjs

@@ -0,0 +1,18 @@
+import { i as readExplainer } from "../../explainer-map-DW4XCcY0.mjs";
+// check/rules/one-competency-per-page.ts
+var one_competency_per_page_default = {
+	id: "one-competency-per-page",
+	url: "https://lernapps.net/tooling/rules/#one-competency-per-page",
+	description: "Each page of an explainer in format 2 names at most one competency of the learning map.",
+	severity: "hint",
+	run: ({ project }) => {
+		const explainer = project === void 0 ? void 0 : readExplainer(project);
+		if (explainer === void 0) return void 0;
+		return explainer.pages.filter((page) => page.competencies.length > 1).map((page) => ({
+			where: page.where,
+			found: `the page names ${page.competencies.length} competencies (${page.competencies.join(", ")})`,
+			fix: "Give each competency a page of its own, and keep one id in competencies on each; several pages for one large competency are fine"
+		}));
+	}
+};
+export { one_competency_per_page_default as default };

package/dist/check/rules/prerequisites-linked.mjs

@@ -0,0 +1,38 @@
+import { a as strandsOf, i as readExplainer, n as loadMap, r as mapUrl, t as competencyPage } from "../../explainer-map-DW4XCcY0.mjs";
+// check/rules/prerequisites-linked.ts
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var prerequisites_linked_default = {
+	id: "prerequisites-linked",
+	url: "https://lernapps.net/tooling/rules/#prerequisites-linked",
+	description: "Every prerequisite that a page's competencies require and the app does not practise has a recap page in the app or a link to its page on the learning map.",
+	severity: "hint",
+	run: async ({ project }) => {
+		const explainer = project === void 0 ? void 0 : readExplainer(project);
+		if (explainer === void 0 || explainer.strand === "none") return void 0;
+		const [subject = ""] = explainer.strand.split("/");
+		const loaded = await loadMap(mapUrl(subject));
+		if ("failed" in loaded) return [];
+		const strandOf = strandsOf(loaded.map);
+		const requires = new Map(loaded.map.strands.flatMap((strand) => strand.competencies.map((competency) => [competency.id, competency.requires ?? []])));
+		const practised = new Set(explainer.pages.flatMap((page) => page.competencies));
+		const recapped = new Set(explainer.pages.flatMap((page) => page.recap === void 0 ? [] : [page.recap]));
+		const problems = [];
+		for (const page of explainer.pages) {
+			const named = /* @__PURE__ */ new Set();
+			for (const id of page.competencies) for (const prerequisite of requires.get(id) ?? []) {
+				const of = strandOf.get(prerequisite);
+				if (of === void 0 || practised.has(prerequisite) || named.has(prerequisite)) continue;
+				named.add(prerequisite);
+				if (recapped.has(`${subject}/${prerequisite}`)) continue;
+				if (new RegExp(`/apps/map/${escape(subject)}/c/${escape(prerequisite)}(?:/|\\b)`).test(page.text)) continue;
+				problems.push({
+					where: page.where,
+					found: `${id} requires ${subject}/${prerequisite} (strand ${subject}/${of}), which the app does not practise; no recap page repeats it and the page does not link it`,
+					fix: `Name it in the page's text with a link to ${competencyPage(subject, prerequisite)}, or add a recap page (recap: ${subject}/${prerequisite}, descriptive blocks only) before this page`
+				});
+			}
+		}
+		return problems;
+	}
+};
+export { prerequisites_linked_default as default };