@openstax/ts-utils 1.38.0-beta → 1.38.1

package/dist/esm/misc/jwks.d.ts

@@ -3,5 +3,5 @@ import type { JWK } from 'node-jose';
 export type JwksFetcher = (uri: string) => Promise<{
     keys: JWK.RawKey[];
 }>;
-export declare const getJwksClient: (iss: string, fetcher?: JwksFetcher) => JwksClient;
+export declare const getJwksClient: (jwksUri: string, fetcher?: JwksFetcher) => JwksClient;
 export declare const getJwksKey: (iss: string, kid?: string, fetcher?: JwksFetcher) => Promise<import("jwks-rsa").SigningKey>;

package/dist/esm/misc/jwks.js

@@ -1,10 +1,10 @@
 import { JwksClient } from 'jwks-rsa';
 import { memoize } from './helpers';
-export const getJwksClient = memoize((iss, fetcher) => {
-    const jwksUri = new URL('/.well-known/jwks.json', iss).toString();
+export const getJwksClient = memoize((jwksUri, fetcher) => {
     return new JwksClient({ jwksUri, fetcher });
 });
 export const getJwksKey = memoize(async (iss, kid, fetcher) => {
-    const client = getJwksClient(iss, fetcher);
+    const jwksUri = new URL('/.well-known/jwks.json', iss).toString();
+    const client = getJwksClient(jwksUri, fetcher);
     return client.getSigningKey(kid);
 });

package/dist/esm/services/lrsGateway/attempt-utils.d.ts

@@ -14,16 +14,21 @@ export type ActivityState = {
     mostRecentWithCompleted?: AttemptEntry;
 };
 export declare const matchAttempt: (statement: UXapiStatement) => boolean;
-export declare const matchAttemptCompleted: (attempt: UXapiStatement) => (statement: UXapiStatement) => boolean;
-export declare const matchAttemptScored: (attempt: UXapiStatement) => (statement: UXapiStatement) => boolean;
+export declare const matchAttemptCompleted: (attempt: UXapiStatement) => (statement: UXapiStatement) => boolean | "";
+export declare const matchAttemptScored: (attempt: UXapiStatement) => (statement: UXapiStatement) => boolean | "";
 export declare const resolveAttempts: (statements: UXapiStatement[], options?: {
     activityIRI?: string;
     parentActivityAttempt?: string;
 }) => UXapiStatement[];
 export declare const resolveCompletedForAttempt: (statements: UXapiStatement[], attempt: UXapiStatement, activityIRI?: string) => UXapiStatement | undefined;
 export declare const resolveScoredForAttempt: (statements: UXapiStatement[], attempt: UXapiStatement, activityIRI?: string) => UXapiStatement | undefined;
-export declare const oldestStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
-export declare const mostRecentStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
+export declare const getStatementTimeString: (statement: UXapiStatement) => string;
+export declare const getStatementTime: (statement: UXapiStatement) => Date;
+export declare const oldestStatement: (items: UXapiStatement[]) => UXapiStatement | undefined;
+export declare const mostRecentStatement: (items: UXapiStatement[]) => UXapiStatement | undefined;
+export declare const oldestEntry: (items: AttemptEntry[]) => AttemptEntry | undefined;
+export declare const mostRecentEntry: (items: AttemptEntry[]) => AttemptEntry | undefined;
+export declare const bestEntry: (items: AttemptEntry[]) => AttemptEntry | undefined;
 export declare const resolveAttemptInfo: (statements: UXapiStatement[], options?: {
     activityIRI?: string;
     currentAttempt?: string;

package/dist/esm/services/lrsGateway/attempt-utils.js

@@ -21,14 +21,14 @@ export const EXT_PENDING_SCORING = 'https://openstax.org/xapi/extensions/pending
 export const matchAttempt = (statement) => statement.verb.id === Verb.Attempted;
 export const matchAttemptCompleted = (attempt) => (statement) => {
     var _a, _b;
-    return statement.verb.id === Verb.Completed
+    return statement.verb.id === Verb.Completed && attempt.id
         && statement.context !== undefined
         && ((_a = statement.context.statement) === null || _a === void 0 ? void 0 : _a.id) === attempt.id
         && statement.context.registration === ((_b = attempt.context) === null || _b === void 0 ? void 0 : _b.registration);
 };
 export const matchAttemptScored = (attempt) => (statement) => {
     var _a, _b;
-    return statement.verb.id === Verb.Scored
+    return statement.verb.id === Verb.Scored && attempt.id
         && statement.context !== undefined
         && ((_a = statement.context.statement) === null || _a === void 0 ? void 0 : _a.id) === attempt.id
         && statement.context.registration === ((_b = attempt.context) === null || _b === void 0 ? void 0 : _b.registration);
@@ -42,101 +42,86 @@ export const resolveAttempts = (statements, options) => statements.filter(statem
 export const resolveCompletedForAttempt = (statements, attempt, activityIRI) => statements.find(statement => matchAttemptCompleted(attempt)(statement)
     && (!activityIRI || statement.object.id === activityIRI));
 export const resolveScoredForAttempt = (statements, attempt, activityIRI) => {
-    // Prefer the most recent Scored
-    const scored = mostRecentStatement(statements.filter(s => matchAttemptScored(attempt)(s) && (!activityIRI || s.object.id === activityIRI)));
-    if (scored)
-        return scored;
-    // if no scored found, return most recent Completed with a score for the attempt.
-    const completedWithScore = mostRecentStatement(statements.filter(s => matchAttemptCompleted(attempt)(s) &&
-        (!activityIRI || s.object.id === activityIRI) && s.result &&
-        s.result.score &&
-        (s.result.score.scaled !== undefined)));
-    return completedWithScore;
+    // scored or completed statements that contain a score in their
+    // result are 'scoring statements' for our purposes.
+    const scoringStatements = statements.filter(s => {
+        var _a;
+        return (matchAttemptScored(attempt)(s) || matchAttemptCompleted(attempt)(s))
+            && ((_a = s.result) === null || _a === void 0 ? void 0 : _a.score)
+            && (!activityIRI || s.object.id === activityIRI);
+    });
+    return mostRecentStatement(scoringStatements);
+};
+const resolveAttemptEntries = (statements, attempts, activityIRI) => attempts.reduce((acc, attempt) => {
+    const completed = resolveCompletedForAttempt(statements, attempt, activityIRI);
+    const scored = resolveScoredForAttempt(statements, attempt, activityIRI);
+    acc.push({ attempt, completed, scored });
+    return acc;
+}, []);
+export const getStatementTimeString = (statement) => 'stored' in statement && statement.stored ? statement.stored : statement.timestamp;
+export const getStatementTime = (statement) => parseISO(getStatementTimeString(statement));
+const findByComparator = (comparator, extractor) => (items) => {
+    return items.reduce((best, item) => {
+        if (!best)
+            return item;
+        return comparator(extractor(best), extractor(item)) ? best : item;
+    }, undefined);
+};
+export const oldestStatement = findByComparator(isBefore, getStatementTime);
+export const mostRecentStatement = findByComparator(isAfter, getStatementTime);
+export const oldestEntry = findByComparator(isBefore, (entry) => getStatementTime(entry.attempt));
+export const mostRecentEntry = findByComparator(isAfter, (entry) => getStatementTime(entry.attempt));
+const scaledScoreForEntry = (entry) => {
+    var _a;
+    const scoringStatement = entry.scored;
+    const score = (_a = scoringStatement === null || scoringStatement === void 0 ? void 0 : scoringStatement.result) === null || _a === void 0 ? void 0 : _a.score;
+    if (!score)
+        return { score: undefined, entry };
+    // Prefer scaled, otherwise normalize raw/max if available
+    if (score.scaled !== undefined)
+        return { score: score.scaled, entry };
+    if (score.raw !== undefined && score.max !== undefined && score.max !== 0) {
+        return { score: score.raw / score.max, entry };
+    }
+    return { score: undefined, entry };
 };
-export const oldestStatement = (statements) => statements.reduce((result, statement) => result && isBefore(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
-export const mostRecentStatement = (statements) => statements.reduce((result, statement) => result && isAfter(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
+/*
+ * the 'best' entry is the one with the highest scaled score.
+ * if two entries have no score, the most recent is considered best.
+ */
+export const bestEntry = findByComparator((a, b) => {
+    // if neither has a score, use the most recent
+    if (a.score === undefined && b.score === undefined) {
+        return isAfter(getStatementTime(a.entry.attempt), getStatementTime(b.entry.attempt));
+    }
+    if (a.score === undefined)
+        return false;
+    if (b.score === undefined)
+        return true;
+    return a.score > b.score;
+}, scaledScoreForEntry);
 export const resolveAttemptInfo = (statements, options) => {
     // TODO optimize. i'm 100% that this could all be done in one iteration but i'm not messing around with that for now.
     const attempts = resolveAttempts(statements, options);
-    /* attempts that have a completed statement */
-    const resolveAttemptsWithCompleted = (statements, attempts, activityIRI) => attempts.reduce((acc, attempt) => {
-        const completed = resolveCompletedForAttempt(statements, attempt, activityIRI);
-        if (completed)
-            acc.push({ attempt, completed });
-        return acc;
-    }, []);
-    const completedPairs = resolveAttemptsWithCompleted(statements, attempts, options === null || options === void 0 ? void 0 : options.activityIRI);
-    const completedAttempts = completedPairs.length;
-    /* the last attempt sorted by timestamp */
-    const currentAttempt = (options === null || options === void 0 ? void 0 : options.currentAttempt)
-        ? attempts.find(attempt => attempt.id === options.currentAttempt)
-        : (options === null || options === void 0 ? void 0 : options.currentPreference) === 'oldest'
-            ? oldestStatement(attempts)
-            : mostRecentStatement(attempts);
-    const current = currentAttempt
-        ? {
-            attempt: currentAttempt,
-            completed: resolveCompletedForAttempt(statements, currentAttempt, options === null || options === void 0 ? void 0 : options.activityIRI),
-            scored: resolveScoredForAttempt(statements, currentAttempt, options === null || options === void 0 ? void 0 : options.activityIRI),
-        }
-        : undefined;
-    const currentAttemptStatements = currentAttempt
+    const attemptEntries = resolveAttemptEntries(statements, attempts, options === null || options === void 0 ? void 0 : options.activityIRI);
+    const completedEntries = attemptEntries.filter((entry) => !!entry.completed);
+    const current = (options === null || options === void 0 ? void 0 : options.currentAttempt)
+        ? attemptEntries.find(({ attempt }) => attempt.id === options.currentAttempt)
+        : (options === null || options === void 0 ? void 0 : options.currentPreference) === 'oldest' /* the attempt sorted by timestamp */
+            ? oldestEntry(attemptEntries)
+            : mostRecentEntry(attemptEntries);
+    const currentAttemptStatements = current
         ? statements.filter(statement => {
             var _a;
             return (!(options === null || options === void 0 ? void 0 : options.activityIRI) || statement.object.id === options.activityIRI) &&
-                ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === currentAttempt.id;
+                ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === current.attempt.id;
         })
         : [];
-    const mostRecentPair = completedPairs.reduce((cur, pair) => {
-        if (!cur)
-            return pair;
-        return isAfter(parseISO(cur.attempt.timestamp), parseISO(pair.attempt.timestamp)) ? cur : pair;
-    }, undefined);
-    const mostRecentWithCompleted = mostRecentPair
-        ? {
-            attempt: mostRecentPair.attempt,
-            completed: resolveCompletedForAttempt(statements, mostRecentPair.attempt, options === null || options === void 0 ? void 0 : options.activityIRI),
-            scored: resolveScoredForAttempt(statements, mostRecentPair.attempt, options === null || options === void 0 ? void 0 : options.activityIRI),
-        }
-        : undefined;
-    const scaledForAttempt = (attempt) => {
-        var _a;
-        // resolveScoredForAttempt may return a Scored, or fallback to a Completed that has a score
-        const picked = resolveScoredForAttempt(statements, attempt, options === null || options === void 0 ? void 0 : options.activityIRI);
-        const score = (_a = picked === null || picked === void 0 ? void 0 : picked.result) === null || _a === void 0 ? void 0 : _a.score;
-        if (!score)
-            return undefined;
-        // Prefer scaled, otherwise normalize raw/max if available
-        if (score.scaled !== undefined)
-            return score.scaled;
-        if (score.raw !== undefined && score.max !== undefined && score.max !== 0) {
-            return score.raw / score.max;
-        }
-        return undefined;
-    };
-    let bestAttempt = completedPairs.reduce((best, { attempt }) => {
-        const bScaled = best !== undefined ? scaledForAttempt(best) : undefined;
-        const aScaled = scaledForAttempt(attempt);
-        if (bScaled === undefined)
-            return aScaled === undefined ? best : attempt;
-        if (aScaled === undefined)
-            return best;
-        return aScaled > bScaled ? attempt : best;
-    }, undefined);
-    // Fallback if no attempt had a score, use newest completed as best
-    if (!bestAttempt && mostRecentPair) {
-        bestAttempt = mostRecentPair.attempt;
-    }
-    const best = bestAttempt
-        ? {
-            attempt: bestAttempt,
-            completed: resolveCompletedForAttempt(statements, bestAttempt, options && options.activityIRI),
-            scored: resolveScoredForAttempt(statements, bestAttempt, options && options.activityIRI),
-        }
-        : undefined;
+    const mostRecentWithCompleted = mostRecentEntry(completedEntries);
+    const best = bestEntry(completedEntries);
     return {
         attempts: attempts.length,
-        completedAttempts,
+        completedAttempts: completedEntries.length,
         currentAttemptStatements,
         current,
         best,

package/dist/esm/services/lrsGateway/xapiUtils.d.ts

@@ -1,6 +1,6 @@
 import { AccountsGateway, MappedUserInfo } from '../accountsGateway';
 import { AuthProvider } from '../authProvider';
-import { ActivityState } from './attempt-utils';
+import { ActivityState, AttemptEntry } from './attempt-utils';
 import { LrsGateway } from '.';
 export interface Grade {
     activityProgress: 'Initialized' | 'Started' | 'inProgress' | 'Submitted' | 'Completed';
@@ -23,15 +23,8 @@ export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration:
 }) => Promise<{
     [key: string]: ActivityState;
 }>;
-export declare const getScoreGrade: (score: {
-    scaled?: number;
-    raw?: number;
-    min?: number;
-    max?: number;
-}, options: {
+export declare const getScoreGrade: (entry: Partial<AttemptEntry>, options: {
     maxScore?: number;
-    startedAt?: string;
-    submittedAt?: string;
     userId?: string;
 }) => Grade;
 export type Progress = {

package/dist/esm/services/lrsGateway/xapiUtils.js

@@ -1,6 +1,6 @@
 import partition from 'lodash/fp/partition';
 import { roundToPrecision } from '../..';
-import { EXT_PENDING_SCORING, resolveAttemptInfo } from './attempt-utils';
+import { EXT_PENDING_SCORING, getStatementTimeString, resolveAttemptInfo } from './attempt-utils';
 export const getRegistrationAttemptInfo = async (lrs, registration, options) => {
     const { currentPreference, ...xapiOptions } = options !== null && options !== void 0 ? options : {};
     const allStatements = await lrs.getAllXapiStatements({ ...xapiOptions, registration });
@@ -23,60 +23,47 @@ export const getRegistrationAttemptInfo = async (lrs, registration, options) =>
 // lti: http://www.imsglobal.org/spec/lti-ags/v2p0#score-publish-service
 // ltijs: https://cvmcosta.me/ltijs/#/grading
 // Note: "min" is currently completely ignored
-export const getScoreGrade = (score, options) => {
-    const { raw, scaled, max } = score;
-    const { maxScore, startedAt, submittedAt, userId } = options;
+export const getScoreGrade = (entry, options) => {
+    var _a, _b, _c, _d, _e;
+    const { raw, scaled, max } = ((_b = (_a = entry.scored) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.score) || {};
+    const { maxScore, userId } = options;
     const scoreMaximum = maxScore !== null && maxScore !== void 0 ? maxScore : 100;
     const scoreGiven = raw && max
         ? scoreMaximum / max * raw
         : scaled
             ? scaled * scoreMaximum
             : 0;
-    const submission = {};
-    if (startedAt) {
-        submission.startedAt = startedAt;
-    }
-    if (submittedAt) {
-        submission.submittedAt = submittedAt;
-    }
+    const submission = {
+        startedAt: entry.attempt ? getStatementTimeString(entry.attempt) : undefined,
+        submittedAt: entry.completed ? getStatementTimeString(entry.completed) : undefined,
+    };
+    const pendingManual = entry.scored === undefined
+        && ((_e = (_d = (_c = entry.completed) === null || _c === void 0 ? void 0 : _c.result) === null || _d === void 0 ? void 0 : _d.extensions) === null || _e === void 0 ? void 0 : _e[EXT_PENDING_SCORING]) === 'true';
     return {
         userId,
-        activityProgress: submittedAt ? 'Completed' : 'Started',
+        activityProgress: entry.completed ? 'Completed' : 'Started',
         // canvas assumes that anything that isn't 'FullyGraded' requires manual grading and displays a "needs grading" icon.
         // if you warp your mind you can consider the portion of the assignment which is completed to be fully graded.
-        gradingProgress: 'FullyGraded',
+        gradingProgress: pendingManual ? 'PendingManual' : 'FullyGraded',
         scoreMaximum,
         scoreGiven: roundToPrecision(scoreGiven, -2),
         submission,
     };
 };
 // These methods assign 0's to incomplete activities
-const pickAttemptAndCompletedOrScored = (state, gradePreference) => {
-    var _a;
-    const entry = (gradePreference === 'best' ? state.best : state.current);
-    return {
-        attempt: entry === null || entry === void 0 ? void 0 : entry.attempt,
-        completedOrScored: (_a = entry === null || entry === void 0 ? void 0 : entry.scored) !== null && _a !== void 0 ? _a : entry === null || entry === void 0 ? void 0 : entry.completed,
-        completed: entry === null || entry === void 0 ? void 0 : entry.completed,
-    };
+const getGradingAttemptEntry = (state, gradePreference) => {
+    return (gradePreference === 'best' ? state.best : state.current) || {};
 };
 const getCompletedActivityStateGradeAndProgress = ({ name, scoreMaximum, state, userId, gradePreference = 'current' }) => {
-    var _a, _b, _c;
-    const { attempt, completedOrScored, completed } = pickAttemptAndCompletedOrScored(state, gradePreference);
-    const grade = getScoreGrade(((_a = completedOrScored === null || completedOrScored === void 0 ? void 0 : completedOrScored.result) === null || _a === void 0 ? void 0 : _a.score) || {}, {
+    const entry = getGradingAttemptEntry(state, gradePreference);
+    const grade = getScoreGrade(entry, {
         maxScore: scoreMaximum,
-        startedAt: attempt === null || attempt === void 0 ? void 0 : attempt.timestamp,
-        submittedAt: completed === null || completed === void 0 ? void 0 : completed.timestamp,
         userId,
     });
-    // If this Completed is explicitly "pending scoring", surface that in the grade.
-    if (((_c = (_b = completedOrScored === null || completedOrScored === void 0 ? void 0 : completedOrScored.result) === null || _b === void 0 ? void 0 : _b.extensions) === null || _c === void 0 ? void 0 : _c[EXT_PENDING_SCORING]) === 'true') {
-        grade.gradingProgress = 'PendingManual';
-    }
     return {
         grade,
         progress: {
-            scaled: completedOrScored ? 1 : 0,
+            scaled: entry.completed ? 1 : 0,
         },
         name,
     };
@@ -89,7 +76,7 @@ export const getCompletedUserInfosGradeAndProgress = (infos, scoreMaximum, grade
     gradePreference,
 }));
 export const getCurrentGrade = async (services, registration, options) => {
-    var _a;
+    var _a, _b;
     const user = await services.ltiAuthProvider.getUser();
     if (!user) {
         return null;
@@ -107,7 +94,7 @@ export const getCurrentGrade = async (services, registration, options) => {
             gradePreference,
         });
     }
-    if (userInfo.current && userInfo.current.completed || !incompleteAttemptCallback) {
+    if (((_b = userInfo.current) === null || _b === void 0 ? void 0 : _b.completed) || !incompleteAttemptCallback) {
         return getCompletedActivityStateGradeAndProgress({
             name,
             scoreMaximum,
@@ -128,8 +115,8 @@ export const getAssignmentGrades = async (services, assignmentIRI, registration,
     }
     // Partition based on whether the chosen preference has a completed attempt
     const [incompleteInfo, completedInfo] = partition((info) => {
-        const { completedOrScored } = pickAttemptAndCompletedOrScored(info.data, gradePreference);
-        return completedOrScored === undefined;
+        const { completed } = getGradingAttemptEntry(info.data, gradePreference);
+        return completed === undefined;
     })(mappedInfo);
     return getCompletedUserInfosGradeAndProgress(completedInfo, scoreMaximum, gradePreference).concat(await incompleteAttemptsCallback(incompleteInfo));
 };