@anantagnanam/lms 0.2.0 → 0.3.0

package/astro/draft-queue.ts

@@ -0,0 +1,95 @@
+export type DraftState = "saved" | "pending" | "saving" | "failed" | "conflict";
+export interface DraftWrite<T> {
+  value: T;
+  expectedDraftRevision: number;
+}
+const fingerprint = (value: object) =>
+  JSON.stringify(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
+
+/** Serialize writes and preserve the exact unacknowledged request for retries. */
+export class DraftQueue<T extends object> {
+  revision: number;
+  state: DraftState = "saved";
+  private latest: T;
+  private acknowledged: string;
+  private retry?: DraftWrite<T>;
+  private running?: Promise<void>;
+  private disposed = false;
+  constructor(
+    value: T,
+    revision: number,
+    private send: (write: DraftWrite<T>) => Promise<{ draftRevision: number }>,
+    private changed: (state: DraftState) => void,
+  ) {
+    this.latest = structuredClone(value);
+    this.acknowledged = fingerprint(value);
+    this.revision = revision;
+  }
+  get dirty() {
+    return !!this.retry || fingerprint(this.latest) !== this.acknowledged;
+  }
+  private emit(state: DraftState) {
+    this.state = state;
+    if (!this.disposed) this.changed(state);
+  }
+  update(value: T) {
+    this.latest = structuredClone(value);
+    if (!["failed", "conflict", "saving"].includes(this.state))
+      this.emit(this.dirty ? "pending" : "saved");
+  }
+  flush(): Promise<void> {
+    if (this.disposed) return Promise.reject(new Error("This form has closed."));
+    if (this.state === "conflict")
+      return Promise.reject(new Error("Review the saved draft before continuing."));
+    if (this.running) return this.running;
+    this.running = this.drain().finally(() => {
+      this.running = undefined;
+    });
+    return this.running;
+  }
+  private async drain() {
+    while (this.dirty && !this.disposed) {
+      const write = this.retry ?? {
+        value: structuredClone(this.latest),
+        expectedDraftRevision: this.revision,
+      };
+      this.retry = write;
+      this.emit("saving");
+      try {
+        const result = await this.send(structuredClone(write));
+        this.revision = result.draftRevision;
+        this.acknowledged = fingerprint(write.value);
+        this.retry = undefined;
+      } catch (error) {
+        const failure = error as { code?: string; status?: number };
+        // A definite rejection did not persist the write. Allow corrected values on retry.
+        if (
+          failure.status &&
+          failure.status < 500 &&
+          failure.status !== 408 &&
+          failure.status !== 429 &&
+          failure.code !== "DRAFT_CONFLICT"
+        )
+          this.retry = undefined;
+        this.emit((error as { code?: string })?.code === "DRAFT_CONFLICT" ? "conflict" : "failed");
+        throw error;
+      }
+    }
+    this.emit(this.dirty ? "pending" : "saved");
+  }
+  conflict() {
+    this.emit("conflict");
+  }
+  /** Only after the learner has reviewed the current saved draft. */
+  reconcile(value: T, revision: number, keepLocal: boolean) {
+    if (this.running) throw new Error("Wait for the current save to finish.");
+    this.revision = revision;
+    this.acknowledged = fingerprint(value);
+    this.retry = undefined;
+    if (!keepLocal) this.latest = structuredClone(value);
+    this.emit(this.dirty ? "pending" : "saved");
+  }
+  dispose() {
+    this.disposed = true;
+  }
+}

package/astro/media-player.ts

@@ -22,8 +22,23 @@ export function initializeMedia(call: Call) {
     let busy = false;
     let pending = false;
     let failed = false;
+    let disposed = false;
     let lastSave = Date.now();
     const enabled = Boolean(lesson && lesson.dataset.preview !== "true");
+    const seekBookmark = () => {
+      const raw = new URLSearchParams(window.location.hash.slice(1)).get("t");
+      if (!ready || disposed || raw === null || !/^\d+(?:\.\d+)?$/.test(raw)) return;
+      const position = Number(raw);
+      if (!Number.isFinite(position) || position > 86_400) return;
+      try {
+        media.currentTime = Number.isFinite(media.duration)
+          ? Math.min(position, Math.max(0, media.duration - 0.1))
+          : position;
+        status.textContent = `Bookmark at ${Math.floor(media.currentTime / 60)}:${String(Math.floor(media.currentTime % 60)).padStart(2, "0")}. Press play when ready.`;
+      } catch {
+        status.textContent = "This media is not seekable yet.";
+      }
+    };
     button.hidden = !enabled;
     const restore = () => {
       if (ready) return;
@@ -41,9 +56,10 @@ export function initializeMedia(call: Call) {
         speed.value = String(media.playbackRate);
         status.textContent = `Resumed at ${Math.floor(position / 60)}:${String(Math.floor(position % 60)).padStart(2, "0")}.`;
       }
+      seekBookmark();
     };
     const save = async () => {
-      if (!enabled || !ready || failed || !Number.isFinite(media.currentTime)) return;
+      if (disposed || !enabled || !ready || failed || !Number.isFinite(media.currentTime)) return;
       if (busy) {
         pending = true;
         return;
@@ -95,5 +111,14 @@ export function initializeMedia(call: Call) {
     button.addEventListener("click", () => {
       void save();
     });
+    window.addEventListener("hashchange", seekBookmark);
+    document.addEventListener(
+      "astro:before-swap",
+      () => {
+        disposed = true;
+        window.removeEventListener("hashchange", seekBookmark);
+      },
+      { once: true },
+    );
   }
 }

package/astro/pages/author-preview.astro

@@ -2,6 +2,7 @@
 import Layout from "virtual:anantagnanam-lms/layout";
 import LearningShell from "../components/LearningShell.astro";
 import LessonContent from "../components/LessonContent.astro";
+import AssignmentRubric from "../components/AssignmentRubric.astro";
 import { lmsAuthorLessonPreview, loginUrl, LmsError } from "@anantagnanam/lms/server";
 import { loginPath } from "virtual:anantagnanam-lms/config";
 export const prerender = false;
@@ -49,6 +50,7 @@ try {
           <section class="lms-assessment">
             <h2>Your assignment</h2>
             <p class="lms-text">{result.lesson.assignment.instructions}</p>
+            <AssignmentRubric rubric={result.lesson.assignment.rubric} />
             <p>
               {result.lesson.assignment.passingPoints}/{result.lesson.assignment.maxPoints} points
               to pass

package/astro/pages/study.astro

@@ -0,0 +1,180 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import { lmsLearner, loginUrl, lessonUrl, LmsError } from "@anantagnanam/lms/server";
+import { basePath, loginPath } from "virtual:anantagnanam-lms/config";
+import type { Notebook, CourseAgenda, Page } from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+Astro.response.headers.set("X-Robots-Tag", "noindex, nofollow");
+if (!Astro.locals.user)
+  return Astro.redirect(loginUrl(loginPath, Astro.url.pathname + Astro.url.search));
+let courses: Page<{ courseId: string; title: string; slug: string | null }> = {
+  items: [],
+  hasMore: false,
+};
+let notebook: Notebook | undefined;
+let agenda: CourseAgenda | undefined;
+let error = "";
+let agendaError = "";
+const courseId = Astro.url.searchParams.get("courseId");
+try {
+  courses = await lmsLearner(
+    Astro.locals,
+    "learner/study/courses",
+    { cursor: Astro.url.searchParams.get("cursor") ?? undefined, limit: 24 },
+    Astro.url.origin,
+  );
+  if (courseId) {
+    notebook = await lmsLearner(Astro.locals, "learner/notebook", { courseId }, Astro.url.origin);
+    try {
+      agenda = await lmsLearner(Astro.locals, "learner/agenda", { courseId }, Astro.url.origin);
+    } catch (cause) {
+      agendaError = cause instanceof Error ? cause.message : "Course agenda is unavailable.";
+    }
+  }
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "Study tools are unavailable.";
+}
+---
+
+<Layout title="My notebook and agenda" robots="noindex, nofollow">
+  <LearningShell>
+    <h1>My notebook &amp; agenda</h1>
+    <p>Revisit important ideas and plan your next course activity.</p>
+    {error && <p role="alert">{error}</p>}
+    <details open={!courseId}>
+      <summary>Choose an enrolled course</summary>
+      <ul>
+        {courses.items.map((course) => (
+          <li>
+            <a
+              href={`?courseId=${encodeURIComponent(course.courseId)}`}
+              aria-current={course.courseId === courseId ? "page" : undefined}
+            >
+              {course.title}
+            </a>
+          </li>
+        ))}
+      </ul>
+      {!courses.items.length && !error && <p>No enrolled courses on this page.</p>}
+      {courses.hasMore && courses.cursor && (
+        <a href={`?cursor=${encodeURIComponent(courses.cursor)}`}>More courses →</a>
+      )}
+    </details>
+    {notebook && (
+      <>
+        <h2>{notebook.course.title}</h2>
+        <section
+          class="lms-learning-card"
+          data-lms-notebook
+          data-notebook={JSON.stringify(notebook)}
+          data-base-path={basePath}
+        >
+          <h3>Private notebook</h3>
+          <p>
+            Add notes from a lesson. Search this course’s notes, star important ideas, or archive
+            and restore entries. Saved lesson summaries are preserved below.
+          </p>
+          <div class="lms-actions">
+            <label>
+              Search notes <input type="search" maxlength={200} data-lms-note-search />
+            </label>
+            <label>
+              Show{" "}
+              <select data-lms-note-filter>
+                <option value="active">Active notes</option>
+                <option value="starred">Starred notes</option>
+                <option value="archived">Archived notes</option>
+              </select>
+            </label>
+            <button type="button" class="lms-btn lms-btn-outline" data-lms-notebook-refresh>
+              Reload saved notes
+            </button>
+          </div>
+          <p data-lms-feedback aria-live="polite"></p>
+          <div data-lms-note-list></div>
+          <noscript>
+            Enable JavaScript to search and edit notebook entries. Your learner data export also
+            includes these notes.
+          </noscript>
+        </section>
+        <section class="lms-learning-card" data-lms-agenda data-course-id={courseId}>
+          <h3>Course agenda</h3>
+          {agendaError && <p>{agendaError} Your private notebook remains available.</p>}
+          {agenda && (
+            <>
+              <p>
+                Assignment deadlines, live sessions and upcoming lesson releases from your enrolled
+                course edition. Lesson access and prerequisites still apply.
+              </p>
+              <div class="lms-actions">
+                <label>
+                  Display timezone{" "}
+                  <select data-lms-timezone>
+                    <option value="UTC">UTC</option>
+                  </select>
+                </label>
+                <label>
+                  <input type="checkbox" data-lms-agenda-upcoming /> Upcoming only
+                </label>
+                <button type="button" class="lms-btn lms-btn-outline" data-lms-calendar-download>
+                  Download upcoming calendar (.ics)
+                </button>
+              </div>
+              <p>
+                The download is a snapshot for your calendar app. It does not update automatically;
+                revisit the course for changes.
+              </p>
+              <p data-lms-feedback aria-live="polite"></p>
+              <ul class="lms-agenda-list">
+                {agenda.events.map((event) => (
+                  <li data-lms-agenda-event data-status={event.status}>
+                    <strong>
+                      {
+                        {
+                          assignment: "Assignment due",
+                          live: "Live session",
+                          release: "Lesson release",
+                        }[event.kind]
+                      }
+                      : {event.title}
+                    </strong>
+                    <p>
+                      <time datetime={event.startsAt} data-lms-date>
+                        {new Date(event.startsAt).toLocaleString("en-GB", { timeZone: "UTC" })} UTC
+                      </time>
+                      {event.endsAt && (
+                        <>
+                          {" "}
+                          –{" "}
+                          <time datetime={event.endsAt} data-lms-date>
+                            {new Date(event.endsAt).toLocaleString("en-GB", { timeZone: "UTC" })}{" "}
+                            UTC
+                          </time>
+                        </>
+                      )}
+                    </p>
+                    <p class="lms-badge">{event.status}</p>
+                    {event.available ? (
+                      <a href={lessonUrl(basePath, agenda.course.slug, event.lessonId)}>
+                        Open lesson →
+                      </a>
+                    ) : (
+                      <p>{event.reason}</p>
+                    )}
+                  </li>
+                ))}
+              </ul>
+              {!agenda.events.length && <p>This course has no dated activities.</p>}
+              <p data-lms-agenda-empty hidden>
+                No upcoming activities in this view.
+              </p>
+            </>
+          )}
+        </section>
+      </>
+    )}
+  </LearningShell>
+</Layout>

package/astro/quiz-drafts.ts

@@ -1,87 +1,23 @@
 import type { Answers } from "@anantagnanam/lms/types";
-
-export type DraftState = "saved" | "pending" | "saving" | "failed" | "conflict";
+import { DraftQueue, type DraftState } from "./draft-queue.js";
+export type { DraftState } from "./draft-queue.js";
 export interface DraftWrite {
   answers: Answers;
   expectedDraftRevision: number;
 }
-const fingerprint = (answers: Answers) =>
-  JSON.stringify(Object.entries(answers).sort(([a], [b]) => a.localeCompare(b)));
-
-/** One writer per form. Keep an unacknowledged request intact for lost-response retries. */
-export class QuizDraftQueue {
-  revision: number;
-  state: DraftState = "saved";
-  private latest: Answers;
-  private acknowledged: string;
-  private retry?: DraftWrite;
-  private running?: Promise<void>;
-  private disposed = false;
+/** Retain the quiz interface while sharing the reliable writer with assignments. */
+export class QuizDraftQueue extends DraftQueue<Answers> {
   constructor(
     answers: Answers,
     revision: number,
-    private send: (write: DraftWrite) => Promise<{ draftRevision: number }>,
-    private changed: (state: DraftState) => void,
+    send: (write: DraftWrite) => Promise<{ draftRevision: number }>,
+    changed: (state: DraftState) => void,
   ) {
-    this.latest = structuredClone(answers);
-    this.acknowledged = fingerprint(answers);
-    this.revision = revision;
-  }
-  get dirty() {
-    return !!this.retry || fingerprint(this.latest) !== this.acknowledged;
-  }
-  private emit(state: DraftState) {
-    this.state = state;
-    if (!this.disposed) this.changed(state);
-  }
-  update(answers: Answers) {
-    this.latest = structuredClone(answers);
-    if (!["failed", "conflict", "saving"].includes(this.state))
-      this.emit(this.dirty ? "pending" : "saved");
-  }
-  flush(): Promise<void> {
-    if (this.disposed) return Promise.reject(new Error("This quiz form has closed."));
-    if (this.state === "conflict")
-      return Promise.reject(new Error("Review the saved answers before continuing."));
-    if (this.running) return this.running;
-    this.running = this.drain().finally(() => {
-      this.running = undefined;
-    });
-    return this.running;
-  }
-  private async drain() {
-    while (this.dirty && !this.disposed) {
-      const write = this.retry ?? {
-        answers: structuredClone(this.latest),
-        expectedDraftRevision: this.revision,
-      };
-      this.retry = write;
-      this.emit("saving");
-      try {
-        const result = await this.send(structuredClone(write));
-        this.revision = result.draftRevision;
-        this.acknowledged = fingerprint(write.answers);
-        this.retry = undefined;
-      } catch (error) {
-        this.emit((error as { code?: string })?.code === "DRAFT_CONFLICT" ? "conflict" : "failed");
-        throw error;
-      }
-    }
-    this.emit(this.dirty ? "pending" : "saved");
-  }
-  /** Called only after the learner reviews the current remote draft. */
-  conflict() {
-    this.emit("conflict");
-  }
-  reconcile(answers: Answers, revision: number, keepLocal: boolean) {
-    if (this.running) throw new Error("Wait for the current save to finish.");
-    this.revision = revision;
-    this.acknowledged = fingerprint(answers);
-    this.retry = undefined;
-    if (!keepLocal) this.latest = structuredClone(answers);
-    this.emit(this.dirty ? "pending" : "saved");
-  }
-  dispose() {
-    this.disposed = true;
+    super(
+      answers,
+      revision,
+      (write) => send({ answers: write.value, expectedDraftRevision: write.expectedDraftRevision }),
+      changed,
+    );
   }
 }