scorm-again 2.6.3 → 2.6.5

package/src/cmi/scorm2004/cmi.ts

@@ -107,7 +107,9 @@ export class CMI extends BaseRootCMI {
    * @private
    */
   set _version(_version: string) {
-    throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+    throw new Scorm2004ValidationError(
+      scorm2004_errors.READ_ONLY_ELEMENT as number,
+    );
   }
 
   /**
@@ -121,11 +123,13 @@ export class CMI extends BaseRootCMI {
 
   /**
    * Setter for __children. Just throws an error.
-   * @param {number} _children
+   * @param {string} _children
    * @private
    */
-  set _children(_children: number) {
-    throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+  set _children(_children: string) {
+    throw new Scorm2004ValidationError(
+      scorm2004_errors.READ_ONLY_ELEMENT as number,
+    );
   }
 
   /**
@@ -160,7 +164,9 @@ export class CMI extends BaseRootCMI {
    */
   set completion_threshold(completion_threshold: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._completion_threshold = completion_threshold;
     }
@@ -180,7 +186,9 @@ export class CMI extends BaseRootCMI {
    */
   set credit(credit: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._credit = credit;
     }
@@ -200,7 +208,9 @@ export class CMI extends BaseRootCMI {
    */
   set entry(entry: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._entry = entry;
     }
@@ -212,7 +222,9 @@ export class CMI extends BaseRootCMI {
    */
   get exit(): string {
     if (!this.jsonString) {
-      throw new Scorm2004ValidationError(scorm2004_errors.WRITE_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.WRITE_ONLY_ELEMENT as number,
+      );
     }
     return this._exit;
   }
@@ -241,7 +253,9 @@ export class CMI extends BaseRootCMI {
    */
   set launch_data(launch_data: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._launch_data = launch_data;
     }
@@ -261,7 +275,9 @@ export class CMI extends BaseRootCMI {
    */
   set learner_id(learner_id: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._learner_id = learner_id;
     }
@@ -281,7 +297,9 @@ export class CMI extends BaseRootCMI {
    */
   set learner_name(learner_name: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._learner_name = learner_name;
     }
@@ -319,7 +337,9 @@ export class CMI extends BaseRootCMI {
    */
   set max_time_allowed(max_time_allowed: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._max_time_allowed = max_time_allowed;
     }
@@ -339,7 +359,9 @@ export class CMI extends BaseRootCMI {
    */
   set mode(mode: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._mode = mode;
     }
@@ -380,7 +402,9 @@ export class CMI extends BaseRootCMI {
    */
   set scaled_passing_score(scaled_passing_score: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._scaled_passing_score = scaled_passing_score;
     }
@@ -392,7 +416,9 @@ export class CMI extends BaseRootCMI {
    */
   get session_time(): string {
     if (!this.jsonString) {
-      throw new Scorm2004ValidationError(scorm2004_errors.WRITE_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.WRITE_ONLY_ELEMENT as number,
+      );
     }
     return this._session_time;
   }
@@ -459,7 +485,9 @@ export class CMI extends BaseRootCMI {
    */
   set time_limit_action(time_limit_action: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._time_limit_action = time_limit_action;
     }
@@ -479,7 +507,9 @@ export class CMI extends BaseRootCMI {
    */
   set total_time(total_time: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       this._total_time = total_time;
     }

package/src/cmi/scorm2004/comments.ts

@@ -17,7 +17,7 @@ export class CMICommentsFromLMS extends CMIArray {
   constructor() {
     super({
       children: scorm2004_constants.comments_children,
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
     });
   }
@@ -34,7 +34,7 @@ export class CMICommentsFromLearner extends CMIArray {
   constructor() {
     super({
       children: scorm2004_constants.comments_children,
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
     });
   }
@@ -83,7 +83,9 @@ export class CMICommentsObject extends BaseCMI {
    */
   set comment(comment: string) {
     if (this.initialized && this._readOnlyAfterInit) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       if (
         check2004ValidFormat(comment, scorm2004_regex.CMILangString4000, true)
@@ -107,7 +109,9 @@ export class CMICommentsObject extends BaseCMI {
    */
   set location(location: string) {
     if (this.initialized && this._readOnlyAfterInit) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {
         this._location = location;
@@ -129,7 +133,9 @@ export class CMICommentsObject extends BaseCMI {
    */
   set timestamp(timestamp: string) {
     if (this.initialized && this._readOnlyAfterInit) {
-      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+      throw new Scorm2004ValidationError(
+        scorm2004_errors.READ_ONLY_ELEMENT as number,
+      );
     } else {
       if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {
         this._timestamp = timestamp;

package/src/cmi/scorm2004/interactions.ts

@@ -17,7 +17,7 @@ export class CMIInteractions extends CMIArray {
   constructor() {
     super({
       children: scorm2004_constants.interactions_children,
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
     });
   }
@@ -43,12 +43,12 @@ export class CMIInteractionsObject extends BaseCMI {
   constructor() {
     super();
     this.objectives = new CMIArray({
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
       children: scorm2004_constants.objectives_children,
     });
     this.correct_responses = new CMIArray({
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
       children: scorm2004_constants.correct_responses_children,
     });
@@ -80,12 +80,12 @@ export class CMIInteractionsObject extends BaseCMI {
     this._latency = "";
     this._description = "";
     this.objectives = new CMIArray({
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
       children: scorm2004_constants.objectives_children,
     });
     this.correct_responses = new CMIArray({
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
       children: scorm2004_constants.correct_responses_children,
     });
@@ -124,7 +124,7 @@ export class CMIInteractionsObject extends BaseCMI {
   set type(type: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {
@@ -148,7 +148,7 @@ export class CMIInteractionsObject extends BaseCMI {
   set timestamp(timestamp: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {
@@ -172,7 +172,7 @@ export class CMIInteractionsObject extends BaseCMI {
   set weighting(weighting: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {
@@ -197,7 +197,7 @@ export class CMIInteractionsObject extends BaseCMI {
   set learner_response(learner_response: string) {
     if (this.initialized && (this._type === "" || this._id === "")) {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       let nodes = [];
@@ -215,39 +215,39 @@ export class CMIInteractionsObject extends BaseCMI {
 
           for (let i = 0; i < nodes.length; i++) {
             if (response_type?.delimiter2) {
-              const values = nodes[i].split(response_type.delimiter2);
+              const values = nodes[i]?.split(response_type.delimiter2);
 
-              if (values.length === 2) {
-                if (!values[0].match(formatRegex)) {
+              if (values?.length === 2) {
+                if (!values[0]?.match(formatRegex)) {
                   throw new Scorm2004ValidationError(
-                    scorm2004_errors.TYPE_MISMATCH,
+                    scorm2004_errors.TYPE_MISMATCH as number,
                   );
                 } else {
                   if (
                     !response_type.format2 ||
-                    !values[1].match(new RegExp(response_type.format2))
+                    !values[1]?.match(new RegExp(response_type.format2))
                   ) {
                     throw new Scorm2004ValidationError(
-                      scorm2004_errors.TYPE_MISMATCH,
+                      scorm2004_errors.TYPE_MISMATCH as number,
                     );
                   }
                 }
               } else {
                 throw new Scorm2004ValidationError(
-                  scorm2004_errors.TYPE_MISMATCH,
+                  scorm2004_errors.TYPE_MISMATCH as number,
                 );
               }
             } else {
-              if (!nodes[i].match(formatRegex)) {
+              if (!nodes[i]?.match(formatRegex)) {
                 throw new Scorm2004ValidationError(
-                  scorm2004_errors.TYPE_MISMATCH,
+                  scorm2004_errors.TYPE_MISMATCH as number,
                 );
               } else {
                 if (nodes[i] !== "" && response_type.unique) {
                   for (let j = 0; j < i; j++) {
                     if (nodes[i] === nodes[j]) {
                       throw new Scorm2004ValidationError(
-                        scorm2004_errors.TYPE_MISMATCH,
+                        scorm2004_errors.TYPE_MISMATCH as number,
                       );
                     }
                   }
@@ -257,13 +257,15 @@ export class CMIInteractionsObject extends BaseCMI {
           }
         } else {
           throw new Scorm2004ValidationError(
-            scorm2004_errors.GENERAL_SET_FAILURE,
+            scorm2004_errors.GENERAL_SET_FAILURE as number,
           );
         }
 
         this._learner_response = learner_response;
       } else {
-        throw new Scorm2004ValidationError(scorm2004_errors.TYPE_MISMATCH);
+        throw new Scorm2004ValidationError(
+          scorm2004_errors.TYPE_MISMATCH as number,
+        );
       }
     }
   }
@@ -301,7 +303,7 @@ export class CMIInteractionsObject extends BaseCMI {
   set latency(latency: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {
@@ -325,7 +327,7 @@ export class CMIInteractionsObject extends BaseCMI {
   set description(description: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (

package/src/cmi/scorm2004/learner_preference.ts

@@ -44,7 +44,9 @@ export class CMILearnerPreference extends BaseCMI {
    * @private
    */
   set _children(_children: string) {
-    throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
+    throw new Scorm2004ValidationError(
+      scorm2004_errors.READ_ONLY_ELEMENT as number,
+    );
   }
 
   /**

package/src/cmi/scorm2004/objectives.ts

@@ -18,7 +18,7 @@ export class CMIObjectives extends CMIArray {
   constructor() {
     super({
       children: scorm2004_constants.objectives_children,
-      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
       errorClass: Scorm2004ValidationError,
     });
   }
@@ -110,7 +110,7 @@ export class CMIObjectivesObject extends BaseCMI {
   set success_status(success_status: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {
@@ -134,7 +134,7 @@ export class CMIObjectivesObject extends BaseCMI {
   set completion_status(completion_status: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {
@@ -158,7 +158,7 @@ export class CMIObjectivesObject extends BaseCMI {
   set progress_measure(progress_measure: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (
@@ -185,7 +185,7 @@ export class CMIObjectivesObject extends BaseCMI {
   set description(description: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED as number,
       );
     } else {
       if (

package/src/cmi/scorm2004/score.ts

@@ -18,9 +18,9 @@ export class Scorm2004CMIScore extends CMIScore {
     super({
       score_children: scorm2004_constants.score_children,
       max: "",
-      invalidErrorCode: scorm2004_errors.READ_ONLY_ELEMENT,
-      invalidTypeCode: scorm2004_errors.TYPE_MISMATCH,
-      invalidRangeCode: scorm2004_errors.VALUE_OUT_OF_RANGE,
+      invalidErrorCode: scorm2004_errors.READ_ONLY_ELEMENT as number,
+      invalidTypeCode: scorm2004_errors.TYPE_MISMATCH as number,
+      invalidRangeCode: scorm2004_errors.VALUE_OUT_OF_RANGE as number,
       decimalRegex: scorm2004_regex.CMIDecimal,
       errorClass: Scorm2004ValidationError,
     });

package/src/cmi/scorm2004/validation.ts

@@ -17,7 +17,7 @@ export function check2004ValidFormat(
   return checkValidFormat(
     value,
     regexPattern,
-    scorm2004_errors.TYPE_MISMATCH,
+    scorm2004_errors.TYPE_MISMATCH as number,
     Scorm2004ValidationError,
     allowEmptyString,
   );
@@ -36,7 +36,7 @@ export function check2004ValidRange(
   return checkValidRange(
     value,
     rangePattern,
-    scorm2004_errors.VALUE_OUT_OF_RANGE,
+    scorm2004_errors.VALUE_OUT_OF_RANGE as number,
     Scorm2004ValidationError,
   );
 }

package/src/exceptions/aicc_exceptions.ts

@@ -15,14 +15,14 @@ export class AICCValidationError extends ValidationError {
     if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {
       super(
         errorCode,
-        aicc_errors[String(errorCode)].basicMessage,
-        aicc_errors[String(errorCode)].detailMessage,
+        aicc_errors[String(errorCode)]?.basicMessage || "Unknown rror",
+        aicc_errors[String(errorCode)]?.detailMessage,
       );
     } else {
       super(
         101,
-        aicc_errors["101"].basicMessage,
-        aicc_errors["101"].detailMessage,
+        aicc_errors["101"]?.basicMessage || "General error",
+        aicc_errors["101"]?.detailMessage,
       );
     }
   }

package/src/exceptions/scorm12_exceptions.ts

@@ -15,14 +15,14 @@ export class Scorm12ValidationError extends ValidationError {
     if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {
       super(
         errorCode,
-        scorm12_errors[String(errorCode)].basicMessage,
-        scorm12_errors[String(errorCode)].detailMessage,
+        scorm12_errors[String(errorCode)]?.basicMessage || "Unknown error",
+        scorm12_errors[String(errorCode)]?.detailMessage,
       );
     } else {
       super(
         101,
-        scorm12_errors["101"].basicMessage,
-        scorm12_errors["101"].detailMessage,
+        scorm12_errors["101"]?.basicMessage ?? "General error",
+        scorm12_errors["101"]?.detailMessage,
       );
     }
   }

package/src/exceptions/scorm2004_exceptions.ts

@@ -15,14 +15,14 @@ export class Scorm2004ValidationError extends ValidationError {
     if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {
       super(
         errorCode,
-        scorm2004_errors[String(errorCode)].basicMessage,
-        scorm2004_errors[String(errorCode)].detailMessage,
+        scorm2004_errors[String(errorCode)]?.basicMessage || "Unknown error",
+        scorm2004_errors[String(errorCode)]?.detailMessage,
       );
     } else {
       super(
         101,
-        scorm2004_errors["101"].basicMessage,
-        scorm2004_errors["101"].detailMessage,
+        scorm2004_errors["101"]?.basicMessage || "General error",
+        scorm2004_errors["101"]?.detailMessage,
       );
     }
   }

package/src/utilities.ts

@@ -68,7 +68,7 @@ export function getSecondsAsISODuration(seconds: number | null): string {
   let duration = "P";
   let remainder = seconds;
   for (const designationsKey in designations) {
-    const current_seconds = designations[designationsKey];
+    const current_seconds = designations[designationsKey] || 1;
     let value = Math.floor(remainder / current_seconds);
     remainder = remainder % current_seconds;
 
@@ -259,7 +259,7 @@ export function unflatten(data: StringKeyMap): object {
 
       while (m) {
         cur = cur[prop] || (cur[prop] = m[2] ? [] : {});
-        prop = m[2] || m[1];
+        prop = m[2] || m[1] || "";
         m = regex.exec(p);
       }
 
@@ -278,7 +278,7 @@ export function unflatten(data: StringKeyMap): object {
 export function countDecimals(num: number): number {
   if (Math.floor(num) === num || String(num).indexOf(".") < 0) return 0;
   const parts = num.toString().split(".")[1];
-  return parts.length || 0;
+  return parts?.length || 0;
 }
 
 /**

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);
+    });
+  });
+});