@intellectif/lk-core 1.10.0 → 1.10.1

package/dist/{scoring-Db1CZeAn.cjs → scoring-Bmfu8RS5.cjs}

@@ -223,16 +223,27 @@ const ROUNDING_MODES = [
 const MAX_ROUNDING_DP = 15;
 /**
 * The rounding policy `value` holds, or `undefined` for none (`undefined` or
-* `null`). A malformed one would reach {@link gte} as `10 ** undefined` and
-* turn a perfect score into a fail with no error, so it throws here instead.
+* `null`): the check for an optional `rounding`. Anything else is checked by
+* {@link requireRoundingPolicy}.
 *
-* Internal. Every function that takes a `rounding` option checks it here, so
-* each refuses the same policies with the same message; `scoring/index.ts`
-* does not re-export it.
+* Internal, as is {@link requireRoundingPolicy}: `scoring/index.ts` re-exports
+* neither.
 */
 function roundingPolicyOf(value) {
-	if (value === void 0 || value === null) return;
-	const { mode, dp } = value;
+	return value === void 0 || value === null ? void 0 : requireRoundingPolicy(value);
+}
+/**
+* The rounding policy `value` holds. A malformed one would reach the rounding
+* as `10 ** undefined` and turn a perfect score into a fail with no error, so
+* it throws here instead; so does a missing one, `undefined` or `null`, where a
+* policy is required.
+*
+* Every function that takes a policy, as an argument or a `rounding` option,
+* checks it here or through {@link roundingPolicyOf}, so each refuses the same
+* policies with the same message.
+*/
+function requireRoundingPolicy(value) {
+	const { mode, dp } = value ?? {};
 	if (!ROUNDING_MODES.includes(mode) || typeof dp !== "number" || !Number.isInteger(dp) || dp < 0 || dp > MAX_ROUNDING_DP) {
 		const describe = (field) => typeof field === "string" ? JSON.stringify(field) : typeof field === "number" || field === void 0 ? String(field) : typeof field === "object" ? "an object" : `a ${typeof field}`;
 		throw new RangeError(`Invalid rounding policy (mode ${describe(mode)}, dp ${describe(dp)}): expected { mode: 'half-up' | 'half-even' | 'floor' | 'ceil', dp: a whole number from 0 to ${MAX_ROUNDING_DP} }.`);
@@ -263,8 +274,9 @@ function scaled(value, dp) {
 * Normalises `-0` to `0` without touching anything else. `-0` JSON-serialises
 * as `0` but fails `Object.is(-0, 0)`, which surprises a strict-equality
 * gradebook comparison. Deliberately NOT `|| 0`: that also swallowed `NaN`
-* (reachable with an absurd `dp`, where `10 ** dp` overflows to Infinity) and
-* turned a visible failure into a plausible-looking grade of zero.
+* (reached with an absurd `dp`, where `10 ** dp` overflows to Infinity, before
+* policies were checked) and turned a visible failure into a plausible-looking
+* grade of zero.
 */
 function noNegZero(value) {
 	return Object.is(value, -0) ? 0 : value;
@@ -275,8 +287,15 @@ function noNegZero(value) {
 * Idempotent for every mode: rounding an already-rounded value returns it
 * unchanged. That matters because a composed score is rounded once and then
 * compared through {@link gte}, which rounds again.
+*
+* @throws RangeError when `policy` is not a {@link RoundingPolicy} — for a
+* non-finite `value` too, which a policy returns unchanged.
 */
 function roundGrade(value, policy) {
+	return round(value, requireRoundingPolicy(policy));
+}
+/** {@link roundGrade} under a policy {@link requireRoundingPolicy} returned. */
+function round(value, policy) {
 	if (!Number.isFinite(value)) return value;
 	const factor = 10 ** policy.dp;
 	const raw = scaled(value, policy.dp);
@@ -307,9 +326,13 @@ function halfAway(raw) {
 * shown one number and recorded against another. Rounding both sides — and
 * allowing an epsilon — makes "what the learner sees" and "what the gradebook
 * decides" the same comparison.
+*
+* @throws RangeError when `policy` is not a {@link RoundingPolicy}. It is read
+* once, so both sides are rounded under the same one.
 */
 function gte(value, threshold, policy) {
-	return roundGrade(value, policy) >= roundGrade(threshold, policy) - EPSILON;
+	const checked = requireRoundingPolicy(policy);
+	return round(value, checked) >= round(threshold, checked) - EPSILON;
 }
 /**
 * Classifies a value into a band by **flooring**: the highest band whose `min`
@@ -338,10 +361,16 @@ const DEFAULT_PASS_THRESHOLD = .7;
 * the rounding band, and this SDK does not alter historical grades without an
 * explicit decision. Absent, the comparison is the exact raw `>=` it has
 * always been.
+*
+* The policy is checked at the call, as `score()`'s `rounding` option is:
+* `null` reads as no policy, and one that cannot be applied — an unknown
+* `mode`, or a `dp` that is not a whole number from 0 to 15 — throws a
+* `RangeError` instead of quietly failing the comparison.
 */
 function computePassThreshold(activityData, score, rounding) {
+	const policy = roundingPolicyOf(rounding);
 	const threshold = activityData.passThreshold ?? .7;
-	return rounding === void 0 ? score >= threshold : gte(score, threshold, rounding);
+	return policy === void 0 ? score >= threshold : gte(score, threshold, policy);
 }
 /**
 * Selects the authored overall feedback for a result: `feedback.correct` when
@@ -1162,8 +1191,11 @@ function rejectedField(slotIds) {
 * until every item has a grade. An outcome whose score cannot be a grade out of
 * its `maxScore` is not a grade either: it is held the same way and named in
 * `rejectedSlotIds`.
+*
+* @throws RangeError when `policy.rounding` is not a `RoundingPolicy`.
 */
 function composeAssessmentScore(sections, policy) {
+	const rounding = requireRoundingPolicy(policy.rounding);
 	const pendingAll = [];
 	const rejectedAll = [];
 	const unscorableAll = [];
@@ -1201,7 +1233,7 @@ function composeAssessmentScore(sections, policy) {
 			earnedPoints,
 			gradedMaxPoints,
 			maxPoints,
-			score: roundGrade(raw, policy.rounding),
+			score: roundGrade(raw, rounding),
 			appliedThreshold,
 			pendingSlotIds,
 			rejectedSlotIds,
@@ -1218,13 +1250,13 @@ function composeAssessmentScore(sections, policy) {
 		gradedMaxPoints: partial.gradedMaxPoints,
 		maxPoints: partial.maxPoints,
 		score: partial.score,
-		passed: partial.appliedThreshold === null || partial.gradedMaxPoints === 0 ? true : gte(partial.score, partial.appliedThreshold, policy.rounding),
+		passed: partial.appliedThreshold === null || partial.gradedMaxPoints === 0 ? true : gte(partial.score, partial.appliedThreshold, rounding),
 		appliedThreshold: partial.appliedThreshold,
 		pendingSlotIds: partial.pendingSlotIds,
 		...rejectedField(partial.rejectedSlotIds),
 		unscorableSlotIds: partial.unscorableSlotIds
 	}));
-	const score = roundGrade(scored.reduce((sum, section) => sum + section.score * section.normalizedWeight, 0), policy.rounding);
+	const score = roundGrade(scored.reduce((sum, section) => sum + section.score * section.normalizedWeight, 0), rounding);
 	const status = pendingAll.length > 0 ? "provisional" : "final";
 	if (status === "provisional") return {
 		sections: scored,
@@ -1246,7 +1278,7 @@ function composeAssessmentScore(sections, policy) {
 		...rejectedField(rejectedAll),
 		unscorableSlotIds: unscorableAll
 	};
-	const overallOk = gte(score, policy.passThreshold, policy.rounding);
+	const overallOk = gte(score, policy.passThreshold, rounding);
 	const sectionsOk = scored.every((section) => section.passed);
 	const passed = overallOk && sectionsOk;
 	return {
@@ -2639,4 +2671,4 @@ Object.defineProperty(exports, "validateSpeechAssessment", {
 	}
 });
 
-//# sourceMappingURL=scoring-Db1CZeAn.cjs.map
+//# sourceMappingURL=scoring-Bmfu8RS5.cjs.map