@intellectif/lk-core 0.11.0 → 0.12.0

package/dist/index.js

@@ -10,14 +10,14 @@ import {
   outcomeFromGrade,
   roundGrade,
   score
-} from "./chunk-ZTY4UIUD.js";
+} from "./chunk-RK2NVTHZ.js";
 import {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   validateXAPIStatement,
   xAPIBuilder,
   xapiDefinitionFor
-} from "./chunk-IXXMYJI7.js";
+} from "./chunk-UQPNJP2O.js";
 import {
   ItemGroupSchema,
   RedactedItemGroupSchema,
@@ -32,7 +32,7 @@ import {
   validateActivity,
   validateItemGroup,
   writtenResponseJsonSchema
-} from "./chunk-XGCTAQSS.js";
+} from "./chunk-7JMMPE7O.js";
 import {
   ActivitySchemaError,
   BlankConfigSchema,
@@ -69,11 +69,16 @@ import {
   WrittenResponseDataSchema,
   WrittenResponseRubricCriterionSchema,
   WrittenResponseRubricSchema,
+  checkMedia,
   countWords,
+  covers,
   defineActivityType,
   fillInTheBlanksType,
   getActivityTypeDescriptor,
+  isMissingId,
   isRecord,
+  isUnset,
+  isUnwritten,
   issue,
   levenshteinDistance,
   matchText,
@@ -82,7 +87,7 @@ import {
   registerActivityType,
   registeredActivityTypes,
   writtenResponseType
-} from "./chunk-FIS5KBCE.js";
+} from "./chunk-FVN37GIH.js";
 
 // src/content-hash.ts
 function canonicalJson(value, seen = /* @__PURE__ */ new Set()) {
@@ -586,6 +591,261 @@ function diffResponses(before, after) {
   return entries;
 }
 
+// src/authoring/item-group.ts
+function createItemGroupDraft(context) {
+  const issued = /* @__PURE__ */ new Set();
+  const newId = () => {
+    const id = context.newId();
+    if (typeof id !== "string" || id === "") {
+      throw new Error("createItemGroupDraft: newId() must return a non-empty string.");
+    }
+    if (issued.has(id)) {
+      throw new Error(
+        `createItemGroupDraft: newId() returned "${id}" twice. Ids within one draft must differ.`
+      );
+    }
+    issued.add(id);
+    return id;
+  };
+  return {
+    schemaVersion: "1.0",
+    type: "item-group",
+    id: newId(),
+    stimulus: { id: newId(), kind: "text", body: "" },
+    items: []
+  };
+}
+function validateItemGroupDraft(draft) {
+  const issues = [];
+  if (!isRecord(draft)) {
+    issues.push(
+      issue("ig_not_an_object", [], "A group must be an object with a stimulus and its items.")
+    );
+    return { status: "invalid", issues };
+  }
+  issues.push(...checkGroupIdentity(draft));
+  if (isRecord(draft.stimulus)) {
+    issues.push(...checkStimulus(draft.stimulus));
+  } else if (isUnset(draft.stimulus)) {
+    issues.push(
+      issue(
+        "ig_stimulus_required",
+        ["stimulus"],
+        "Add the passage, recording or image the questions are about."
+      )
+    );
+  }
+  issues.push(...checkItems(draft));
+  const parsed = ItemGroupSchema.safeParse(draft, { reportInput: true });
+  if (!parsed.success) {
+    for (const schemaIssue of parsed.error.issues) {
+      const path = schemaIssue.path.map(String);
+      if (issues.some((known) => covers(known.path, path))) {
+        continue;
+      }
+      if (path.length > 0 && refusesEmpty(draft, schemaIssue)) {
+        issues.push(
+          issue(
+            "null_not_allowed",
+            path,
+            "This field cannot be null. Leave it out if it is optional, or give it a value."
+          )
+        );
+        continue;
+      }
+      issues.push({
+        path,
+        message: schemaIssue.message,
+        code: schemaIssue.code,
+        severity: "invalid"
+      });
+    }
+  }
+  const stored = validateItemGroup(draft);
+  if (issues.length === 0 && stored.success) {
+    return { status: "complete", data: stored.data, issues };
+  }
+  if (issues.length === 0) {
+    for (const error of stored.success ? [] : stored.errors) {
+      issues.push({ ...error, severity: "invalid" });
+    }
+  }
+  const invalid = issues.some((found) => found.severity !== "incomplete");
+  return { status: invalid ? "invalid" : "incomplete", issues };
+}
+function checkGroupIdentity(draft) {
+  const issues = [];
+  if (draft.schemaVersion !== "1.0") {
+    issues.push(
+      issue(
+        "schema_version_invalid",
+        ["schemaVersion"],
+        'The draft must have schemaVersion "1.0". A draft from createItemGroupDraft has it.'
+      )
+    );
+  }
+  if (draft.type !== "item-group") {
+    issues.push(issue("type_mismatch", ["type"], `The draft's type must be "item-group".`));
+  }
+  if (isMissingId(draft.id)) {
+    issues.push(issue("id_required", ["id"], "The group has no id."));
+  }
+  if (!isUnset(draft.shuffle) && draft.shuffle !== "none" && draft.shuffle !== "within-group") {
+    issues.push(
+      issue(
+        "ig_shuffle_invalid",
+        ["shuffle"],
+        'Shuffling is either "none" or "within-group". Leave it out to keep the authored order.'
+      )
+    );
+  }
+  return issues;
+}
+var KINDS = /* @__PURE__ */ new Set(["text", "audio", "video", "image", "mixed"]);
+var MEDIA_FOR_KIND = {
+  audio: ["audio"],
+  video: ["video", "embed"],
+  image: ["image"],
+  mixed: ["audio", "video", "image", "embed"]
+};
+function checkStimulus(stimulus) {
+  const issues = [];
+  const at = (...rest) => ["stimulus", ...rest];
+  if (isMissingId(stimulus.id)) {
+    issues.push(issue("ig_stimulus_id_required", at("id"), "The stimulus has no id."));
+  }
+  const kind = stimulus.kind;
+  if (isUnwritten(kind)) {
+    issues.push(
+      issue(
+        "ig_stimulus_kind_required",
+        at("kind"),
+        "Choose what the questions are about: a text, a recording, a video, an image, or a mix."
+      )
+    );
+  } else if (typeof kind !== "string" || !KINDS.has(kind)) {
+    if (typeof kind === "string") {
+      issues.push(
+        issue(
+          "ig_stimulus_kind_invalid",
+          at("kind"),
+          `"${kind}" is not a stimulus kind. Use text, audio, video, image or mixed.`
+        )
+      );
+    }
+    if (isRecord(stimulus.media)) {
+      issues.push(...checkMedia(stimulus.media, at("media")));
+    }
+    return issues;
+  }
+  const hasBody = typeof stimulus.body === "string" && stimulus.body.trim() !== "";
+  const htmlPresent = !isUnset(stimulus.bodyHtml);
+  if (!hasBody && (kind === "text" || kind === "mixed" || htmlPresent)) {
+    issues.push(
+      issue(
+        "ig_stimulus_body_required",
+        at("body"),
+        isUnwritten(stimulus.bodyHtml) ? "Write the passage." : "Write the passage as plain text too. The rich-text version is shown only where a sanitiser is supplied."
+      )
+    );
+  }
+  if (kind !== "text" && isUnset(stimulus.media)) {
+    issues.push(
+      issue("ig_stimulus_media_required", at("media"), "Add the recording, video or image.")
+    );
+  } else if (isRecord(stimulus.media)) {
+    const allowed = MEDIA_FOR_KIND[kind];
+    const mediaType = stimulus.media.type;
+    if (allowed !== void 0 && typeof mediaType === "string" && !allowed.includes(mediaType)) {
+      issues.push(
+        issue(
+          "ig_stimulus_media_kind",
+          at("media", "type"),
+          `A "${kind}" stimulus cannot carry ${mediaType} media. Use ${allowed.join(" or ")}.`
+        )
+      );
+    }
+    issues.push(...checkMedia(stimulus.media, at("media")));
+  }
+  return issues;
+}
+function checkItems(draft) {
+  const issues = [];
+  const items = isUnset(draft.items) ? [] : draft.items;
+  if (!Array.isArray(items)) {
+    return issues;
+  }
+  if (items.length === 0) {
+    issues.push(
+      issue("ig_items_required", ["items"], "Add at least one question about this material.")
+    );
+    return issues;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const repeated = /* @__PURE__ */ new Set();
+  for (const [index, item] of items.entries()) {
+    if (!isRecord(item)) {
+      continue;
+    }
+    const ordinal = index + 1;
+    if (isMissingId(item.id)) {
+      issues.push(
+        issue("ig_item_id_required", ["items", index, "id"], `Question ${ordinal} has no id.`)
+      );
+    } else if (typeof item.id === "string") {
+      if (seen.has(item.id)) {
+        repeated.add(item.id);
+      }
+      seen.add(item.id);
+    }
+    if (item.type === "item-group") {
+      issues.push(
+        issue(
+          "ig_item_nested_group",
+          ["items", index, "type"],
+          "Groups do not nest: every item must be an activity."
+        )
+      );
+      continue;
+    }
+    if (isUnwritten(item.type)) {
+      issues.push(
+        issue(
+          "ig_item_type_required",
+          ["items", index, "type"],
+          `Choose what kind of question ${ordinal} is.`
+        )
+      );
+      continue;
+    }
+    if (typeof item.type !== "string") {
+      continue;
+    }
+    let result;
+    try {
+      result = validateDraft(item.type, item);
+    } catch {
+      issues.push(
+        issue(
+          "ig_item_type_unknown",
+          ["items", index, "type"],
+          `"${item.type}" is not a registered activity type.`
+        )
+      );
+      continue;
+    }
+    for (const found of result.issues) {
+      issues.push({ ...found, path: ["items", String(index), ...found.path] });
+    }
+  }
+  for (const id of repeated) {
+    issues.push(
+      issue("ig_item_id_duplicate", ["items"], `More than one question has the id "${id}".`)
+    );
+  }
+  return issues;
+}
+
 // src/authoring/index.ts
 function validateDraft(type, draft) {
   const descriptor = getActivityTypeDescriptor(type);
@@ -665,12 +925,6 @@ function normalise(found) {
     severity: documented ?? (found.severity === "incomplete" ? "incomplete" : "invalid")
   };
 }
-function covers(reported, failed) {
-  if (failed.length === 0) {
-    return reported.length === 0;
-  }
-  return failed.every((segment, index) => reported[index] === segment);
-}
 
 // src/redact.ts
 function mergePolicy(base, overrides) {
@@ -937,6 +1191,7 @@ export {
   contentHash,
   countWords,
   createDraft,
+  createItemGroupDraft,
   defineActivityType,
   diffResponses,
   entryKeyOf,
@@ -980,6 +1235,7 @@ export {
   validateActivity,
   validateDraft,
   validateItemGroup,
+  validateItemGroupDraft,
   validateXAPIStatement,
   verifyAttemptPlan,
   writtenResponseJsonSchema,