scorm-again 2.6.4 → 2.6.5

package/dist/types/cmi/scorm2004/adl.d.ts

@@ -56,16 +56,22 @@ export declare class ADLNavRequestValid extends BaseCMI {
         [key: string]: NAVBoolean;
     };
     set choice(choice: {
-        [key: string]: string;
+        [key: string]: string | NAVBoolean;
     });
     get jump(): {
         [key: string]: NAVBoolean;
     };
     set jump(jump: {
-        [key: string]: string;
+        [key: string]: string | NAVBoolean;
     });
     toJSON(): {
         previous: string;
         continue: string;
+        choice: {
+            [key: string]: NAVBoolean;
+        };
+        jump: {
+            [key: string]: NAVBoolean;
+        };
     };
 }

package/dist/types/cmi/scorm2004/cmi.d.ts

@@ -37,7 +37,7 @@ export declare class CMI extends BaseRootCMI {
     get _version(): string;
     set _version(_version: string);
     get _children(): string;
-    set _children(_children: number);
+    set _children(_children: string);
     get completion_status(): string;
     set completion_status(completion_status: string);
     get completion_threshold(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scorm-again",
-  "version": "2.6.4",
+  "version": "2.6.5",
   "description": "A modern SCORM JavaScript run-time library for AICC, SCORM 1.2, and SCORM 2004",
   "main": "dist/scorm-again.js",
   "types": "index.d.ts",

package/src/BaseAPI.ts

@@ -1147,6 +1147,8 @@ export default abstract class BaseAPI implements IBaseAPI {
     // if we are terminating the module or closing the browser window/tab, we need to make this fetch ASAP.
     // Some browsers, especially Chrome, do not like synchronous requests to be made when the window is closing.
     if (immediate) {
+      // Apply requestHandler even for immediate requests
+      params = this.settings.requestHandler(params);
       this.performFetch(url, params).then(async (response) => {
         await this.transformResponse(response);
       });

package/src/cmi/scorm2004/adl.ts

@@ -312,9 +312,9 @@ export class ADLNavRequestValid extends BaseCMI {
 
   /**
    * Setter for _choice
-   * @param {{ [key: string]: string }} choice
+   * @param {{ [key: string]: string | NAVBoolean }} choice
    */
-  set choice(choice: { [key: string]: string }) {
+  set choice(choice: { [key: string]: string | NAVBoolean }) {
     if (this.initialized) {
       throw new Scorm2004ValidationError(
         scorm2004_errors.READ_ONLY_ELEMENT as number,
@@ -327,13 +327,13 @@ export class ADLNavRequestValid extends BaseCMI {
     }
     for (const key in choice) {
       if ({}.hasOwnProperty.call(choice, key)) {
-        if (
-          choice[key] !== undefined &&
-          check2004ValidFormat(choice[key], scorm2004_regex.NAVBoolean) &&
-          check2004ValidFormat(key, scorm2004_regex.NAVTarget)
-        ) {
-          this._choice[key] =
-            NAVBoolean[choice[key] as keyof typeof NAVBoolean];
+        if (choice[key] !== undefined && check2004ValidFormat(key, scorm2004_regex.NAVTarget)) {
+          const value = choice[key];
+          if (typeof value === 'string' && check2004ValidFormat(value, scorm2004_regex.NAVBoolean)) {
+            this._choice[key] = NAVBoolean[value as keyof typeof NAVBoolean];
+          } else if (Object.values(NAVBoolean).includes(value as NAVBoolean)) {
+            this._choice[key] = value as NAVBoolean;
+          }
         }
       }
     }
@@ -349,9 +349,9 @@ export class ADLNavRequestValid extends BaseCMI {
 
   /**
    * Setter for _jump
-   * @param {{ [key: string]: string }} jump
+   * @param {{ [key: string]: string | NAVBoolean }} jump
    */
-  set jump(jump: { [key: string]: string }) {
+  set jump(jump: { [key: string]: string | NAVBoolean }) {
     if (this.initialized) {
       throw new Scorm2004ValidationError(
         scorm2004_errors.READ_ONLY_ELEMENT as number,
@@ -364,12 +364,13 @@ export class ADLNavRequestValid extends BaseCMI {
     }
     for (const key in jump) {
       if ({}.hasOwnProperty.call(jump, key)) {
-        if (
-          jump[key] !== undefined &&
-          check2004ValidFormat(jump[key], scorm2004_regex.NAVBoolean) &&
-          check2004ValidFormat(key, scorm2004_regex.NAVTarget)
-        ) {
-          this._jump[key] = NAVBoolean[jump[key] as keyof typeof NAVBoolean];
+        if (jump[key] !== undefined && check2004ValidFormat(key, scorm2004_regex.NAVTarget)) {
+          const value = jump[key];
+          if (typeof value === 'string' && check2004ValidFormat(value, scorm2004_regex.NAVBoolean)) {
+            this._jump[key] = NAVBoolean[value as keyof typeof NAVBoolean];
+          } else if (Object.values(NAVBoolean).includes(value as NAVBoolean)) {
+            this._jump[key] = value as NAVBoolean;
+          }
         }
       }
     }
@@ -388,6 +389,8 @@ export class ADLNavRequestValid extends BaseCMI {
   toJSON(): {
     previous: string;
     continue: string;
+    choice: { [key: string]: NAVBoolean };
+    jump: { [key: string]: NAVBoolean };
   } {
     this.jsonString = true;
     const result = {

package/src/cmi/scorm2004/cmi.ts

@@ -123,10 +123,10 @@ export class CMI extends BaseRootCMI {
 
   /**
    * Setter for __children. Just throws an error.
-   * @param {number} _children
+   * @param {string} _children
    * @private
    */
-  set _children(_children: number) {
+  set _children(_children: string) {
     throw new Scorm2004ValidationError(
       scorm2004_errors.READ_ONLY_ELEMENT as number,
     );

package/test/BaseAPI.requestHandler.spec.ts

@@ -0,0 +1,126 @@
+import { expect } from "expect";
+import * as sinon from "sinon";
+import { Scorm12API } from "../src/Scorm12API";
+import { global_constants } from "../src/constants/api_constants";
+
+describe("BaseAPI requestHandler Tests", () => {
+  let api: Scorm12API;
+  let requestHandlerSpy: sinon.SinonSpy;
+  let fetchStub: sinon.SinonStub;
+
+  beforeEach(() => {
+    // Stub the global fetch to prevent actual HTTP requests
+    fetchStub = sinon.stub(global, "fetch");
+    fetchStub.resolves(
+      new Response(
+        JSON.stringify({
+          result: global_constants.SCORM_TRUE,
+          errorCode: 0,
+        }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        }
+      )
+    );
+
+    // Create a spy for requestHandler
+    requestHandlerSpy = sinon.spy((params) => {
+      // Add a marker to verify the handler was called
+      if (typeof params === "object" && !Array.isArray(params)) {
+        params._requestHandlerCalled = true;
+      }
+      return params;
+    });
+
+    // Initialize API with requestHandler
+    api = new Scorm12API({
+      lmsCommitUrl: "http://example.com/commit",
+      requestHandler: requestHandlerSpy,
+    });
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe("requestHandler with immediate requests", () => {
+    it("should call requestHandler during normal commit", async () => {
+      api.lmsInitialize();
+      api.lmsSetValue("cmi.core.student_name", "Test Student");
+      
+      // Force a commit
+      await api.lmsCommit();
+
+      // Wait a bit for async operations
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(requestHandlerSpy.calledOnce).toBe(true);
+      
+      // Verify the params were transformed
+      const callArgs = fetchStub.firstCall.args[1];
+      const bodyData = JSON.parse(callArgs.body);
+      expect(bodyData._requestHandlerCalled).toBe(true);
+    });
+
+    it("should call requestHandler during terminate (immediate request)", async () => {
+      api.lmsInitialize();
+      api.lmsSetValue("cmi.core.student_name", "Test Student");
+      
+      // Call finish which triggers immediate commit
+      const result = api.lmsFinish();
+      expect(result).toBe(global_constants.SCORM_TRUE);
+
+      // Wait a bit for async operations
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // requestHandler should have been called
+      expect(requestHandlerSpy.called).toBe(true);
+      
+      // Verify the params were transformed even for immediate request
+      const callArgs = fetchStub.firstCall.args[1];
+      const bodyData = JSON.parse(callArgs.body);
+      expect(bodyData._requestHandlerCalled).toBe(true);
+    });
+
+    it("should pass through params when no requestHandler is provided", async () => {
+      // Create API without requestHandler
+      const apiNoHandler = new Scorm12API({
+        lmsCommitUrl: "http://example.com/commit",
+      });
+
+      apiNoHandler.lmsInitialize();
+      apiNoHandler.lmsSetValue("cmi.core.student_name", "Test Student");
+      
+      // Call finish
+      const result = apiNoHandler.lmsFinish();
+      expect(result).toBe(global_constants.SCORM_TRUE);
+
+      // Wait a bit for async operations
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Verify fetch was called but params don't have the marker
+      expect(fetchStub.called).toBe(true);
+      const callArgs = fetchStub.firstCall.args[1];
+      const bodyData = JSON.parse(callArgs.body);
+      expect(bodyData._requestHandlerCalled).toBeUndefined();
+    });
+
+    it("should handle requestHandler errors gracefully", async () => {
+      // Create API with error-throwing requestHandler
+      const errorApi = new Scorm12API({
+        lmsCommitUrl: "http://example.com/commit",
+        requestHandler: () => {
+          throw new Error("RequestHandler error");
+        },
+      });
+
+      errorApi.lmsInitialize();
+      errorApi.lmsSetValue("cmi.core.student_name", "Test Student");
+      
+      // Call finish - should not throw
+      const result = errorApi.lmsFinish();
+      expect(result).toBe(global_constants.SCORM_TRUE);
+    });
+  });
+});