@pie-players/pie-section-player 0.3.71 → 0.3.73

package/README.md

@@ -908,6 +908,36 @@ await controller?.updateItemSession?.("q1", {
 The same controller snapshot is what the persistence strategy saves/loads.
 When a controller is reused for the same `sectionId`/`attemptId`, `updateInput()` refreshes composition input while preserving in-memory section session data.
 
+### Commit at a section boundary
+
+A delivery element coalesces its `session-changed` dispatch, so a response the
+learner has finished entering can still be pending when the section moves. The
+controller commits pending element sessions before item navigation, before
+`updateInput()` snapshots the session for a section swap, and before `persist()`.
+The player also commits when an item shell tears down and when the page goes
+hidden.
+
+The commit reaches the controller, and the controller's own
+`PIE_ITEM_SESSION_CHANGED_EVENT` is what reaches a host. A raw `session-changed`
+does not leave a section: `<pie-item-shell>` stops it and re-dispatches the
+normalized event, so a host listening on `document` for `session-changed`
+receives nothing from inside a section player, before this change or after it.
+Host code persists from the controller's events or from its session snapshot.
+
+Navigation inside a section keeps every item mounted, so nothing is discarded
+and the element's own debounce would complete on its own. The commit still runs
+there because the response belongs to the item being left: a host that persists
+on the navigation event, or a `persist()` that follows it, would otherwise
+snapshot a session the learner had already changed.
+
+`SectionController` stays DOM-free; the player supplies the commit through
+`setPendingSessionCommit()`, declared on `SectionControllerHandle`. The player
+registers it both on the controllers it creates and on one the toolkit has
+already built, since the first section's controller usually exists before the
+player can override the factory. A host-built controller that leaves the method
+unimplemented keeps the behaviour it had before the hook existed, and loses a
+pending response at those boundaries.
+
 ## Content trust boundary
 
 Section-player layouts embed `<pie-item-player>` elements for each item.

package/dist/chunks/pie-api-client-22de9d9c.js

@@ -28,134 +28,141 @@ var i = {
     path: "/api/authoring/release"
   }
 };
-function g(e) {
-  return e ? e.endsWith("/") ? e.slice(0, -1) : e : "";
+function S(n) {
+  return n ? n.endsWith("/") ? n.slice(0, -1) : n : "";
 }
-function r(e, o) {
-  return e ? typeof e == "string" ? {
+function r(n, o) {
+  return n ? typeof n == "string" ? {
     method: o.method,
-    path: e
+    path: n
   } : {
-    method: e.method ?? o.method,
-    path: e.path
+    method: n.method ?? o.method,
+    path: n.path
   } : o;
 }
-function d(e, o) {
-  return /^https?:\/\//i.test(o) ? o : `${g(e)}${o.startsWith("/") ? o : `/${o}`}`;
+function d(n, o) {
+  if (/^https?:\/\//i.test(o)) return o;
+  const e = S(n), t = o.startsWith("/") ? o : `/${o}`;
+  return e.endsWith("/api") && t.startsWith("/api/") ? `${e}${t.slice(4)}` : `${e}${t}`;
 }
-async function l(e, o) {
-  const t = e ?? o;
-  if (!t) return null;
-  if (typeof t.getToken == "function") {
-    const n = await t.getToken();
-    return n ? String(n) : null;
+async function l(n, o) {
+  const e = n ?? o;
+  if (!e) return null;
+  if (typeof e.getToken == "function") {
+    const t = await e.getToken();
+    return t ? String(t) : null;
   }
-  return t.token ? String(t.token) : null;
+  return e.token ? String(e.token) : null;
 }
-async function c(e, o, t, n, a) {
-  const s = typeof AbortController < "u" ? new AbortController() : null, p = typeof n?.timeoutMs == "number" && n.timeoutMs > 0 ? n.timeoutMs : 0, m = s && p > 0 ? setTimeout(() => s.abort(), p) : null;
+var w = 65536;
+function P(n) {
+  return (typeof TextEncoder < "u" ? new TextEncoder().encode(n).length : n.length) > w;
+}
+async function c(n, o, e, t, s, a) {
+  const p = JSON.stringify(e ?? {}), g = a?.keepalive === !0 && !P(p), h = typeof AbortController < "u" ? new AbortController() : null, I = !g && typeof t?.timeoutMs == "number" && t.timeoutMs > 0 ? t.timeoutMs : 0, m = h && I > 0 ? setTimeout(() => h.abort(), I) : null;
   try {
-    const v = {
+    const f = {
       "content-type": "application/json",
-      ...n?.headers || {}
+      ...t?.headers || {}
     };
-    a && (v.authorization = `Bearer ${a}`);
-    const h = await fetch(e, {
+    s && (f.authorization = `Bearer ${s}`);
+    const v = await fetch(n, {
       method: o,
-      headers: v,
-      body: JSON.stringify(t ?? {}),
-      signal: s?.signal
-    }), u = await h.json().catch(() => null);
-    if (!h.ok) {
-      const I = (u && typeof u == "object" && "error" in u ? String(u.error) : "") || `Backend request failed with status ${h.status}`;
-      throw new Error(I);
+      headers: f,
+      body: p,
+      signal: m ? h?.signal : void 0,
+      keepalive: g
+    }), u = await v.json().catch(() => null);
+    if (!v.ok) {
+      const y = (u && typeof u == "object" && "error" in u ? String(u.error) : "") || `Backend request failed with status ${v.status}`;
+      throw new Error(y);
     }
     return u;
   } finally {
     m && clearTimeout(m);
   }
 }
-async function y(e, o, t) {
-  const n = r(e.endpoints?.load, i.load), a = await l(e.auth, o);
-  return c(d(e.baseUrl, n.path), n.method, {
-    itemId: t.itemId,
-    sessionId: t.sessionId,
-    assignmentId: t.assignmentId,
-    env: t.env,
-    overrides: t.requestOptions?.overrides
-  }, e.request, a);
+async function b(n, o, e) {
+  const t = r(n.endpoints?.load, i.load), s = await l(n.auth, o);
+  return c(d(n.baseUrl, t.path), t.method, {
+    itemId: e.itemId,
+    sessionId: e.sessionId,
+    assignmentId: e.assignmentId,
+    env: e.env,
+    overrides: e.requestOptions?.overrides
+  }, n.request, s);
 }
-async function f(e, o, t) {
-  const n = r(e.endpoints?.saveSession, i.saveSession), a = await l(e.auth, o), s = t.session.id || t.sessionId;
-  return c(d(e.baseUrl, n.path), n.method, {
-    sessionId: s,
-    data: t.session.data,
-    env: t.env,
-    itemId: t.itemId,
-    assignmentId: t.assignmentId,
-    models: t.models,
-    passageModels: t.passageModels,
-    overrides: t.requestOptions?.overrides
-  }, e.request, a);
+async function T(n, o, e, t) {
+  const s = r(n.endpoints?.saveSession, i.saveSession), a = await l(n.auth, o), p = e.session.id || e.sessionId;
+  return c(d(n.baseUrl, s.path), s.method, {
+    sessionId: p,
+    data: e.session.data,
+    env: e.env,
+    itemId: e.itemId,
+    assignmentId: e.assignmentId,
+    models: e.models,
+    passageModels: e.passageModels,
+    overrides: e.requestOptions?.overrides
+  }, n.request, a, { keepalive: t?.keepalive === !0 });
 }
-async function S(e, o, t) {
-  const n = r(e.endpoints?.model, i.model), a = await l(e.auth, o), s = t.session.id || t.sessionId;
-  return c(d(e.baseUrl, n.path), n.method, {
-    sessionId: s,
-    data: t.session.data,
-    env: t.env,
-    itemId: t.itemId,
-    assignmentId: t.assignmentId,
-    models: t.models,
-    passageModels: t.passageModels,
-    overrides: t.requestOptions?.overrides
-  }, e.request, a);
+async function A(n, o, e) {
+  const t = r(n.endpoints?.model, i.model), s = await l(n.auth, o), a = e.session.id || e.sessionId;
+  return c(d(n.baseUrl, t.path), t.method, {
+    sessionId: a,
+    data: e.session.data,
+    env: e.env,
+    itemId: e.itemId,
+    assignmentId: e.assignmentId,
+    models: e.models,
+    passageModels: e.passageModels,
+    overrides: e.requestOptions?.overrides
+  }, n.request, s);
 }
-async function w(e, o, t) {
-  const n = r(e.endpoints?.score, i.score), a = await l(e.auth, o), s = t.session.id || t.sessionId;
-  return c(d(e.baseUrl, n.path), n.method, {
-    ...t.options,
-    sessionId: s,
-    data: t.session.data,
-    env: t.env,
-    itemId: t.itemId,
-    assignmentId: t.assignmentId,
-    overrides: t.requestOptions?.overrides
-  }, e.request, a);
+async function O(n, o, e) {
+  const t = r(n.endpoints?.score, i.score), s = await l(n.auth, o), a = e.session.id || e.sessionId;
+  return c(d(n.baseUrl, t.path), t.method, {
+    ...e.options,
+    sessionId: a,
+    data: e.session.data,
+    env: e.env,
+    itemId: e.itemId,
+    assignmentId: e.assignmentId,
+    overrides: e.requestOptions?.overrides
+  }, n.request, s);
 }
-async function P(e, o, t) {
-  const n = r(e.endpoints?.load, i.authoringLoad), a = await l(e.auth, o);
-  return c(d(e.baseUrl, n.path), n.method, {
-    contentId: t.contentId,
-    collectionId: t.collectionId,
-    env: t.env
-  }, e.request, a);
+async function q(n, o, e) {
+  const t = r(n.endpoints?.load, i.authoringLoad), s = await l(n.auth, o);
+  return c(d(n.baseUrl, t.path), t.method, {
+    contentId: e.contentId,
+    collectionId: e.collectionId,
+    env: e.env
+  }, n.request, s);
 }
-async function b(e, o, t) {
-  const n = r(e.endpoints?.saveContent, i.authoringSaveContent), a = await l(e.auth, o);
-  return c(d(e.baseUrl, n.path), n.method, {
-    contentId: t.contentId,
-    collectionId: t.collectionId,
-    config: t.config,
-    env: t.env,
-    options: t.options
-  }, e.request, a);
+async function k(n, o, e) {
+  const t = r(n.endpoints?.saveContent, i.authoringSaveContent), s = await l(n.auth, o);
+  return c(d(n.baseUrl, t.path), t.method, {
+    contentId: e.contentId,
+    collectionId: e.collectionId,
+    config: e.config,
+    env: e.env,
+    options: e.options
+  }, n.request, s);
 }
-async function A(e, o, t) {
-  const n = r(e.endpoints?.releaseContent, i.authoringReleaseContent), a = await l(e.auth, o);
-  return c(d(e.baseUrl, n.path), n.method, {
-    contentId: t.contentId,
-    collectionId: t.collectionId,
-    env: t.env,
-    options: t.options
-  }, e.request, a);
+async function C(n, o, e) {
+  const t = r(n.endpoints?.releaseContent, i.authoringReleaseContent), s = await l(n.auth, o);
+  return c(d(n.baseUrl, t.path), t.method, {
+    contentId: e.contentId,
+    collectionId: e.collectionId,
+    env: e.env,
+    options: e.options
+  }, n.request, s);
 }
 export {
-  P as callPieApiAuthoringLoad,
-  A as callPieApiAuthoringReleaseContent,
-  b as callPieApiAuthoringSaveContent,
-  y as callPieApiDeliveryLoad,
-  S as callPieApiDeliveryModel,
-  f as callPieApiDeliverySave,
-  w as callPieApiDeliveryScore
+  q as callPieApiAuthoringLoad,
+  C as callPieApiAuthoringReleaseContent,
+  k as callPieApiAuthoringSaveContent,
+  b as callPieApiDeliveryLoad,
+  A as callPieApiDeliveryModel,
+  T as callPieApiDeliverySave,
+  O as callPieApiDeliveryScore
 };

package/dist/controllers/SectionController.d.ts

@@ -9,6 +9,7 @@ export declare class SectionController implements SectionControllerHandle {
     private readonly sessionService;
     private readonly itemNavigationService;
     private sessionPersistence;
+    private pendingSessionCommit;
     private state;
     private readonly listeners;
     private readonly trackedRenderables;
@@ -38,6 +39,13 @@ export declare class SectionController implements SectionControllerHandle {
     private mediaAttachWatch;
     private emitChange;
     subscribe(listener: SectionControllerChangeListener): () => void;
+    /**
+     * Register a commit for pending element sessions, run before a boundary this
+     * controller owns. The owner of the section's DOM supplies it; a host-built
+     * controller that never registers one keeps today's behaviour.
+     */
+    setPendingSessionCommit(commit: (() => void) | null): void;
+    private commitPendingItemSessions;
     initialize(input?: unknown): Promise<void>;
     updateInput(input?: unknown): Promise<void>;
     configureSessionPersistence(config: SectionSessionPersistenceConfig): void;