@intellectif/lk-core 1.12.0 → 1.13.0

package/dist/{registry-BClnM5V3.js → registry-Cn2it-y7.js}

@@ -442,7 +442,8 @@ const BUILT_IN_ACTIVITY_TYPES = [
 	"gap-select",
 	"dictation",
 	"read-aloud",
-	"speaking-response"
+	"speaking-response",
+	"matching"
 ];
 /** Whether `type` names an activity type the SDK ships. */
 function isBuiltInActivityType(type) {
@@ -2327,6 +2328,20 @@ const DRAFT_ISSUE_SEVERITY = {
 	gs_choice_text_required: "incomplete",
 	gs_correct_choice_required: "incomplete",
 	gs_correct_choice_unknown: "invalid",
+	mt_prompts_required: "incomplete",
+	mt_prompt_id_required: "invalid",
+	mt_prompt_id_duplicate: "invalid",
+	mt_prompt_text_required: "incomplete",
+	mt_options_too_few: "incomplete",
+	mt_option_id_required: "invalid",
+	mt_option_id_duplicate: "invalid",
+	mt_option_text_required: "incomplete",
+	mt_option_label_required: "incomplete",
+	mt_option_label_duplicate: "invalid",
+	mt_option_use_invalid: "invalid",
+	mt_correct_option_required: "incomplete",
+	mt_correct_option_unknown: "invalid",
+	mt_option_reused: "invalid",
 	wr_prompt_required: "incomplete",
 	wr_min_words_required: "incomplete",
 	wr_min_words_invalid: "invalid",
@@ -3086,6 +3101,10 @@ const ITEM_FINDING_SEVERITY = {
 	gs_choices_duplicate: "warning",
 	gs_bank_no_distractor: "warning",
 	gs_answer_in_passage: "warning",
+	mt_title_reveals_answer: "warning",
+	mt_options_duplicate: "warning",
+	mt_answer_in_prompt: "warning",
+	mt_no_distractor: "warning",
 	wr_criterion_name_duplicate: "warning",
 	wr_levels_unreadable: "warning",
 	ra_text_long_for_time: "warning",
@@ -3356,6 +3375,40 @@ function critiqueGapSelect(draft) {
 	});
 	return findings;
 }
+/** Whether `text` writes out `answer` as whole words — an answer of one short word never counts. */
+function writesOut(text, answer) {
+	const needle = fold(answer);
+	return needle.length > 0 && !isShort(needle) && containsWords(fold(text), needle);
+}
+function critiqueMatching(draft) {
+	const findings = [];
+	const prompts = listOf(draft.prompts);
+	const options = listOf(draft.options);
+	const optionText = (option) => isRecord(option) ? written(option.text) : void 0;
+	const answerOf = (prompt) => isRecord(prompt) ? optionText(options.find((option) => isRecord(option) && option.id === prompt.correctOptionId)) : void 0;
+	const title = written(draft.title);
+	if (title !== void 0 && prompts.some((prompt) => {
+		const answer = answerOf(prompt);
+		return answer !== void 0 && writesOut(title, answer);
+	})) findings.push(finding("mt_title_reveals_answer", ["title"], "The title, which the learner sees, contains the answer to a prompt."));
+	for (const { first, second } of duplicates(options, optionText)) findings.push(finding("mt_options_duplicate", [
+		"options",
+		second,
+		"text"
+	], `Options ${ordinal(first)} and ${ordinal(second)} read the same, so a learner cannot tell them apart.`));
+	prompts.forEach((prompt, index) => {
+		const text = isRecord(prompt) ? written(prompt.text) : void 0;
+		const answer = answerOf(prompt);
+		if (text !== void 0 && answer !== void 0 && writesOut(text, answer)) findings.push(finding("mt_answer_in_prompt", [
+			"prompts",
+			index,
+			"text"
+		], `Prompt ${ordinal(index)} contains "${answer}", the option that answers it, word for word.`));
+	});
+	const promptCount = prompts.filter(isRecord).length;
+	if (draft.optionUse === "once" && promptCount >= 2 && options.length <= promptCount) findings.push(finding("mt_no_distractor", ["options"], `Each option is used once, and there are ${options.length} options for ${promptCount} prompts, so the last prompt is answered by elimination. Add an option that answers no prompt.`));
+	return findings;
+}
 /** Why a criterion's levels cannot be graded on, said to the author. */
 const LEVELS_PROBLEM = {
 	"not-a-list": (criterion) => `Criterion ${criterion}'s levels are not a list`,
@@ -3745,6 +3798,219 @@ function pairsOneToOne(placeholders, gaps) {
 	if (new Set(ids).size !== ids.length || placeholders.size !== ids.length) return false;
 	return ids.every((id) => typeof id === "string" && placeholders.get(id) === 1);
 }
+// src/schemas/matching.ts
+/** Zod schema for one option of the shared list. Loose: a consumer sidecar survives validation. */
+const MatchingOptionSchema = z.looseObject({
+	id: z.string().min(1),
+	label: z.string().min(1).optional(),
+	text: z.string().min(1)
+});
+/** Zod schema for one prompt. Whether its `correctOptionId` exists is checked on the activity. */
+const MatchingPromptSchema = z.looseObject({
+	id: z.string().min(1),
+	text: z.string().min(1),
+	correctOptionId: z.string().min(1),
+	feedback: z.string().optional()
+});
+/** Labels compared as a learner reads them: `"A"`, `" a "` and `"a"` are one key. */
+function labelKey(label) {
+	return label.trim().toLowerCase();
+}
+/** Whether every element of `values` is distinct. */
+const distinct = (values) => new Set(values).size === values.length;
+/**
+* Zod schema validating the full Matching data contract.
+*
+* Five semantic guards, each an authoring error that would otherwise reach a
+* learner:
+*
+* 1. **Prompt ids are unique** — the scorer looks a match up by prompt id, so a
+*    duplicate makes one prompt unscoreable.
+* 2. **Option ids are unique** — an answer key naming an id two options share
+*    means two right answers nobody wrote.
+* 3. **Option labels are unique**, ignoring case and surrounding space — two
+*    options both labelled "C" cannot be told apart by the key the learner
+*    answers with.
+* 4. **Every `correctOptionId` names an option.** An answer key pointing at an
+*    option nobody can pick is a prompt that cannot be passed.
+* 5. **Under `optionUse: 'once'`, no option answers two prompts.** Otherwise
+*    the item says each option is used once while its own key uses one twice.
+*/
+const MatchingDataSchema = z.looseObject({
+	schemaVersion: z.literal("1.0"),
+	type: z.literal("matching"),
+	id: z.string().min(1),
+	title: z.string().min(1),
+	instructions: z.string().optional(),
+	optionsTitle: z.string().optional(),
+	prompts: z.array(MatchingPromptSchema).min(1),
+	options: z.array(MatchingOptionSchema).min(2),
+	optionUse: z.enum(["once", "many"]).optional(),
+	scoringStrategy: z.enum(["all-or-nothing", "partial"]),
+	shuffleOptions: z.boolean().optional(),
+	media: MediaSchema.optional(),
+	feedback: FeedbackSchema.optional(),
+	passThreshold: z.number().min(0).max(1).optional(),
+	locale: z.string().optional(),
+	learningObjectives: z.array(z.string()).optional(),
+	difficultyLevel: z.literal([
+		1,
+		2,
+		3,
+		4,
+		5
+	]).optional(),
+	ai: AiPermissionsSchema.optional()
+}).refine((data) => distinct(data.prompts.map((prompt) => prompt.id)), {
+	error: "Prompt ids must be unique.",
+	path: ["prompts"]
+}).refine((data) => distinct(data.options.map((option) => option.id)), {
+	error: "Option ids must be unique.",
+	path: ["options"]
+}).refine((data) => distinct(data.options.map((option) => option.label).filter((label) => label !== void 0).map(labelKey)), {
+	error: "Option labels must be unique.",
+	path: ["options"]
+}).refine((data) => {
+	const ids = new Set(data.options.map((option) => option.id));
+	return data.prompts.every((prompt) => ids.has(prompt.correctOptionId));
+}, {
+	error: "Each prompt needs a `correctOptionId` that is one of the options.",
+	path: ["prompts"]
+}).refine((data) => data.optionUse !== "once" || distinct(data.prompts.map((prompt) => prompt.correctOptionId)), {
+	error: "With `optionUse: \"once\"`, no option may be the answer to more than one prompt.",
+	path: ["prompts"]
+});
+// src/authoring/matching.ts
+/** Mirrors `MatchingDataSchema`: `options.min(2)`. */
+const MIN_OPTIONS$1 = 2;
+const OPTION_USES = ["once", "many"];
+/**
+* Draft support for `matching`.
+*
+* A new draft has no prompts and no options, and `scoringStrategy` starts at
+* `all-or-nothing`, as on every built-in: partial credit is the author's to
+* give — though an exam's matching task is marked prompt by prompt, so one
+* copied from a paper wants `partial`.
+*
+* As in gap-select, no answer is pre-selected: a prompt's `correctOptionId`
+* starts unwritten, and the draft stays `incomplete` until someone says which
+* option answers each prompt.
+*/
+const matchingAuthoring = {
+	createDraft: ({ newId }) => ({
+		schemaVersion: "1.0",
+		type: "matching",
+		id: newId(),
+		title: "",
+		prompts: [],
+		options: [],
+		scoringStrategy: "all-or-nothing"
+	}),
+	checkDraft: checkMatchingDraft,
+	critique: critiqueMatching
+};
+function checkMatchingDraft(draft) {
+	const issues = checkIdentity(draft, "matching");
+	issues.push(...checkScoringStrategy(draft));
+	if (!isUnset(draft.optionUse) && !OPTION_USES.includes(draft.optionUse)) issues.push(issue("mt_option_use_invalid", ["optionUse"], "Say whether each option is used \"once\" or \"many\" times, or leave it out for \"many\"."));
+	const options = isUnset(draft.options) ? [] : draft.options;
+	const optionIds = /* @__PURE__ */ new Set();
+	if (Array.isArray(options)) issues.push(...checkOptions(options, optionIds));
+	const prompts = isUnset(draft.prompts) ? [] : draft.prompts;
+	if (Array.isArray(prompts)) issues.push(...checkPrompts(prompts, optionIds, draft.optionUse === "once"));
+	issues.push(...checkSharedOptional(draft));
+	return issues;
+}
+/**
+* The shared list. Its uniqueness rules are reported at `options`, where the
+* schema reports them; what is missing from one option, at that option.
+*/
+function checkOptions(options, optionIds) {
+	const issues = [];
+	const atOptions = [];
+	if (options.length < MIN_OPTIONS$1) issues.push(issue("mt_options_too_few", ["options"], `Add at least ${MIN_OPTIONS$1} options to the list the prompts are matched with.`));
+	const repeatedIds = /* @__PURE__ */ new Set();
+	const labels = /* @__PURE__ */ new Map();
+	const repeatedLabels = /* @__PURE__ */ new Set();
+	for (const [index, option] of options.entries()) {
+		if (!isRecord(option)) continue;
+		const ordinal = index + 1;
+		if (isMissingId(option.id)) issues.push(issue("mt_option_id_required", [
+			"options",
+			index,
+			"id"
+		], `Option ${ordinal} has no id.`));
+		else if (typeof option.id === "string") {
+			if (optionIds.has(option.id)) repeatedIds.add(option.id);
+			optionIds.add(option.id);
+		}
+		if (isUnwritten(option.text)) issues.push(issue("mt_option_text_required", [
+			"options",
+			index,
+			"text"
+		], `Write the text of option ${ordinal}.`));
+		if (typeof option.label === "string" && option.label.trim() === "") issues.push(issue("mt_option_label_required", [
+			"options",
+			index,
+			"label"
+		], `Write the label of option ${ordinal}, such as "A" or "iv", or remove it.`));
+		else if (typeof option.label === "string") {
+			const key = labelKey(option.label);
+			if (labels.has(key)) repeatedLabels.add(labels.get(key));
+			else labels.set(key, option.label.trim());
+		}
+	}
+	for (const id of repeatedIds) atOptions.push(issue("mt_option_id_duplicate", ["options"], `More than one option has the id "${id}".`));
+	for (const label of repeatedLabels) atOptions.push(issue("mt_option_label_duplicate", ["options"], `More than one option is labelled "${label}". Learners answer with the label, so each needs its own.`));
+	return [...issues, ...atOptions];
+}
+/**
+* Every prompt. Its uniqueness rule and its answer key against the list are
+* reported at `prompts`, where the schema reports them; a missing id, text or
+* key, at the prompt's own field.
+*/
+function checkPrompts(prompts, optionIds, once) {
+	const issues = [];
+	const atPrompts = [];
+	if (prompts.length === 0) issues.push(issue("mt_prompts_required", ["prompts"], "Add at least one prompt to match with an option."));
+	const seen = /* @__PURE__ */ new Set();
+	const repeated = /* @__PURE__ */ new Set();
+	const answering = /* @__PURE__ */ new Map();
+	for (const [index, prompt] of prompts.entries()) {
+		if (!isRecord(prompt)) continue;
+		const ordinal = index + 1;
+		const name = typeof prompt.id === "string" && prompt.id !== "" ? `"${prompt.id}"` : ordinal;
+		if (isMissingId(prompt.id)) issues.push(issue("mt_prompt_id_required", [
+			"prompts",
+			index,
+			"id"
+		], `Prompt ${ordinal} has no id.`));
+		else if (typeof prompt.id === "string") {
+			if (seen.has(prompt.id)) repeated.add(prompt.id);
+			seen.add(prompt.id);
+		}
+		if (isUnwritten(prompt.text)) issues.push(issue("mt_prompt_text_required", [
+			"prompts",
+			index,
+			"text"
+		], `Write the text of prompt ${ordinal}.`));
+		const key = prompt.correctOptionId;
+		if (isUnwritten(key)) issues.push(issue("mt_correct_option_required", [
+			"prompts",
+			index,
+			"correctOptionId"
+		], `Choose the option that answers prompt ${name}.`));
+		else if (typeof key === "string") {
+			if (!optionIds.has(key)) atPrompts.push(issue("mt_correct_option_unknown", ["prompts"], `Prompt ${name} is answered by "${key}", which is not one of the options.`));
+			answering.set(key, [...answering.get(key) ?? [], String(name)]);
+		}
+	}
+	for (const id of repeated) atPrompts.push(issue("mt_prompt_id_duplicate", ["prompts"], `More than one prompt has the id "${id}".`));
+	if (once) {
+		for (const [optionId, names] of answering) if (names.length > 1) atPrompts.push(issue("mt_option_reused", ["prompts"], `Option "${optionId}" answers prompts ${names.join(" and ")}, but each option is used once. Choose another answer, or let options be used more than once.`));
+	}
+	return [...issues, ...atPrompts];
+}
 // src/schemas/multiple-choice.ts
 /**
 * Zod schema for a single Multiple Choice option. Loose: unknown keys are
@@ -4946,6 +5212,35 @@ const RedactedGapSelectDataSchema = z.strictObject({
 	presentation: z.literal("dropdown").optional(),
 	shuffleChoices: z.boolean().optional()
 });
+/** A redacted matching option: unchanged, because the learner picks from the list. */
+const RedactedMatchingOptionSchema = z.strictObject({
+	id: z.string().min(1),
+	label: z.string().min(1).optional(),
+	text: z.string().min(1)
+});
+/** A redacted prompt: what the learner reads; `correctOptionId` and feedback are gone. */
+const RedactedMatchingPromptSchema = z.strictObject({
+	id: z.string().min(1),
+	text: z.string().min(1)
+});
+/**
+* Redacted Matching data. As in Gap Select, the list the learner picks from
+* survives in full and only the key is withheld: each prompt's
+* `correctOptionId`. `optionUse` survives because it changes what the learner
+* may do — an exam says "You may use any letter more than once" in its
+* instructions, and the component moves an option used once. `scoringStrategy`
+* stays answer-key, as on every type.
+*/
+const RedactedMatchingDataSchema = z.strictObject({
+	...redactedBase,
+	type: z.literal("matching"),
+	instructions: z.string().optional(),
+	optionsTitle: z.string().optional(),
+	prompts: z.array(RedactedMatchingPromptSchema).min(1),
+	options: z.array(RedactedMatchingOptionSchema).min(2),
+	optionUse: z.enum(["once", "many"]).optional(),
+	shuffleOptions: z.boolean().optional()
+});
 /**
 * Redacted Written Response data: the prompt, word bounds and rubric are
 * learner-visible (a rubric tells the learner what they are graded on);
@@ -5185,6 +5480,48 @@ function scoreGapSelect(data, response) {
 		details
 	};
 }
+// src/scoring/activity-scorers/matching.ts
+/**
+* Scores a Matching response.
+*
+* Each prompt is an identity comparison between the option the learner matched
+* it with and `correctOptionId`, as a gap select's gap is. A prompt with no
+* match, or matched with an id that is not an option (a tampered payload, or
+* content edited after the attempt), is scored incorrect and reported as
+* `incorrect-omission`, so an unanswered prompt stays distinguishable from a
+* wrong one downstream.
+*
+* Under `optionUse: 'once'` a response that uses one option twice is scored
+* prompt by prompt like any other: the SDK's component never produces one, and
+* a second use earns nothing the key does not give it, since the key uses each
+* option at most once.
+*/
+function scoreMatching(data, response) {
+	const optionIds = new Set(data.options.map((option) => option.id));
+	const details = [];
+	const perPromptCorrect = [];
+	for (const prompt of data.prompts) {
+		const raw = response.matches[prompt.id];
+		const matched = typeof raw === "string" ? raw : "";
+		const answered = matched !== "" && optionIds.has(matched);
+		const correct = answered && matched === prompt.correctOptionId;
+		perPromptCorrect.push(correct);
+		details.push({
+			itemId: prompt.id,
+			outcome: correct ? "correct" : answered ? "incorrect" : "incorrect-omission",
+			learnerResponse: [matched],
+			correctResponse: [prompt.correctOptionId],
+			weight: 1
+		});
+	}
+	const correctPrompts = perPromptCorrect.filter(Boolean).length;
+	return {
+		score: data.scoringStrategy === "all-or-nothing" ? allOrNothingStrategy(perPromptCorrect) : partialBlankStrategy(correctPrompts, data.prompts.length),
+		maxScore: 1,
+		feedback: null,
+		details
+	};
+}
 // src/scoring/activity-scorers/multiple-choice.ts
 /**
 * Scores a Multiple Choice response. Pure; trusts its typed inputs (validation
@@ -5447,6 +5784,32 @@ const GAP_SELECT_FIELD_POLICY = {
 		feedback: "answer-key"
 	}
 };
+/**
+* Matching: as in Gap Select, the list the learner picks from is public, key
+* by key, and each prompt's `correctOptionId` is the one field withheld.
+* `optionUse` is public because it changes what the learner may do: the
+* component moves an option used once, and the paper says so.
+*/
+const MATCHING_FIELD_POLICY = {
+	...SHARED_PUBLIC_FIELDS,
+	instructions: "public",
+	optionsTitle: "public",
+	optionUse: "public",
+	shuffleOptions: "public",
+	scoringStrategy: "answer-key",
+	feedback: FEEDBACK_FIELD_POLICY,
+	options: {
+		id: "public",
+		label: "public",
+		text: "public"
+	},
+	prompts: {
+		id: "public",
+		text: "public",
+		correctOptionId: "answer-key",
+		feedback: "answer-key"
+	}
+};
 const FILL_IN_THE_BLANKS_FIELD_POLICY = {
 	...SHARED_PUBLIC_FIELDS,
 	instructions: "public",
@@ -5627,6 +5990,26 @@ const gapSelectType = defineActivityType({
 	authoring: gapSelectAuthoring,
 	mediaSlots: () => MAIN_MEDIA
 });
+/** Built-in Matching descriptor. */
+const matchingType = defineActivityType({
+	type: "matching",
+	schema: MatchingDataSchema,
+	scoring: {
+		kind: "sync",
+		score: scoreMatching
+	},
+	isAnswered: (response) => Object.values(response?.matches ?? {}).some((optionId) => optionId !== ""),
+	fieldPolicy: MATCHING_FIELD_POLICY,
+	redactedSchema: RedactedMatchingDataSchema,
+	interop: {
+		xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+		xapiInteractionType: "matching",
+		correctResponsesPattern: (data) => [data.prompts.map((prompt) => `${prompt.id}[.]${prompt.correctOptionId}`).join("[,]")]
+	},
+	interactions: ["option-matched", "submitted"],
+	authoring: matchingAuthoring,
+	mediaSlots: () => MAIN_MEDIA
+});
 /**
 * Built-in Dictation descriptor. Graded synchronously: the score is the
 * character-level similarity of the typed text to the transcript, a pure
@@ -5803,7 +6186,8 @@ const BUILT_IN_DESCRIPTORS = {
 		],
 		authoring: speakingResponseAuthoring,
 		mediaSlots: () => MAIN_MEDIA
-	})
+	}),
+	matching: matchingType
 };
 // src/schemas/read-schema.ts
 /**
@@ -5969,4 +6353,4 @@ function registeredActivityTypes() {
 }
 export { GROUP_CAPTIONS_REVEAL_DICTATION as $, keyPositionFinding as A, SCRIPT_MAX_TURNS as At, countWords as B, READ_ALOUD_MAX_REFERENCE_LENGTH as C, passageWithoutPlaceholders as Ct, SPEECH_ASSESSMENT_MAX_WORDS as D, PLACEHOLDER_RE as Dt, SPEECH_ASSESSMENT_MAX_TEXT_LENGTH as E, FillInTheBlanksDataSchema as Et, matchText as F, isMissingId as G, checkMedia as H, LEVEL_PROBABILITY_TOLERANCE as I, isUnwritten as J, isRecord as K, levelDistribution as L, normaliseFinding as M, maxUnits as Mt, policyFor as N, MultipleChoiceDataSchema as O, MediaSchema as Ot, levenshteinDistance as P, DictationDataSchema as Q, levelKey as R, READ_ALOUD_MAX_DIMENSION_WEIGHT as S, numberedPassage as St, READ_ALOUD_MAX_TAKES as T, revealsAnswer as Tt, coveredPathsOf as U, DRAFT_ISSUE_SEVERITY as V, covers as W, pathKey as X, issue as Y, refusesEmpty as Z, GapSelectDataSchema as _, BUILT_IN_ACTIVITY_TYPES as _t, readSchema as a, STEP as at, ReadAloudDataSchema as b, containsWords as bt, dictationType as c, dictationReferenceWords as ct, multipleChoiceType as d, DICTATION_MAX_EQUIVALENCE_LENGTH as dt, groupCaptionsField as et, readAloudType as f, DICTATION_MAX_TEXT_LENGTH as ft, WrittenResponseDataSchema as g, withValidationScope as gt, defineActivityType as h, normalizeDictationText as ht, isOwnSchema as i, UnknownActivityTypeError as it, finding as j, ScriptSchema as jt, MultipleChoiceOptionMediaSchema as k, RedactedMediaSchema as kt, fillInTheBlanksType as l, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as lt, guardOf as m, codePointLength as mt, registerActivityType as n, DeferredScoringError as nt, standardJsonSchemaOf as o, alignDictation as ot, writtenResponseType as p, DICTATION_MAX_TRANSCRIPT_LENGTH as pt, isUnset as q, registeredActivityTypes as r, RedactedScoringError as rt, MEDIA_FIELD_POLICY as s, alignSequences as st, getActivityTypeDescriptor as t, ActivitySchemaError as tt, gapSelectType as u, DICTATION_MAX_EQUIVALENCES as ut, SPEAKING_MEASURES as v, everyBuiltInTypeHandled as vt, READ_ALOUD_MAX_SECONDS as w, placeholderOrder as wt, CANONICAL_LOCALE_RE as x, fold as xt, SpeakingResponseDataSchema as y, isBuiltInActivityType as yt, readRubricLevels as z };
 
-//# sourceMappingURL=registry-BClnM5V3.js.map
+//# sourceMappingURL=registry-Cn2it-y7.js.map