scorm-again 2.0.0 → 2.2.0

package/src/BaseAPI.ts

@@ -1,154 +1,25 @@
-import { BaseCMI, CMIArray } from "./cmi/common";
+import { CMIArray } from "./cmi/common/array";
 import { ValidationError } from "./exceptions";
 import ErrorCodes, { ErrorCode } from "./constants/error_codes";
 import APIConstants from "./constants/api_constants";
-import { unflatten } from "./utilities";
-
-const global_constants = APIConstants.global;
-const scorm12_error_codes = ErrorCodes.scorm12;
-
-/**
- * Debounce function to delay the execution of a given function.
- *
- * @param func - The function to debounce.
- * @param wait - The number of milliseconds to delay.
- * @param immediate - If `true`, the function will be triggered on the leading edge instead of the trailing.
- * @returns A debounced version of the provided function.
- */
-function debounce<T extends (...args: any[]) => void>(
-  func: T,
-  wait: number,
-  immediate = false,
-): (...args: Parameters<T>) => void {
-  let timeout: ReturnType<typeof setTimeout> | null;
-
-  return function (this: any, ...args: Parameters<T>) {
-    const context = this;
-
-    const later = () => {
-      timeout = null;
-      if (!immediate) func.apply(context, args);
-    };
-
-    const callNow = immediate && !timeout;
-
-    if (timeout) clearTimeout(timeout);
-    timeout = setTimeout(later, wait);
-
-    if (callNow) func.apply(context, args);
-  };
-}
-
-export type Settings = {
-  autocommit: boolean;
-  autocommitSeconds: number;
-  asyncCommit: boolean;
-  sendBeaconCommit: boolean;
-  lmsCommitUrl: boolean | string;
-  dataCommitFormat: string;
-  commitRequestDataType: string;
-  autoProgress: boolean;
-  logLevel: number;
-  selfReportSessionTime: boolean;
-  alwaysSendTotalTime: boolean;
-  strict_errors: boolean;
-  xhrHeaders: RefObject;
-  xhrWithCredentials: boolean;
-  responseHandler: (response: Response) => Promise<ResultObject>;
-  requestHandler: (commitObject: any) => any;
-  onLogMessage: (messageLevel: number, logMessage: string) => void;
-  mastery_override?: boolean;
-};
-
-export type RefObject = {
-  [key: string]: any;
-};
-
-export type ResultObject = {
-  result: string;
-  errorCode: number;
-  navRequest?: string;
-};
-
-export const DefaultSettings: Settings = {
-  autocommit: false,
-  autocommitSeconds: 10,
-  asyncCommit: false,
-  sendBeaconCommit: false,
-  lmsCommitUrl: false,
-  dataCommitFormat: "json",
-  commitRequestDataType: "application/json;charset=UTF-8",
-  autoProgress: false,
-  logLevel: global_constants.LOG_LEVEL_ERROR,
-  selfReportSessionTime: false,
-  alwaysSendTotalTime: false,
-  strict_errors: true,
-  xhrHeaders: {},
-  xhrWithCredentials: false,
-  responseHandler: async function (response: Response): Promise<ResultObject> {
-    if (typeof response !== "undefined") {
-      const httpResult = JSON.parse(await response.text());
-      if (
-        httpResult === null ||
-        !{}.hasOwnProperty.call(httpResult, "result")
-      ) {
-        if (response.status === 200) {
-          return {
-            result: global_constants.SCORM_TRUE,
-            errorCode: 0,
-          };
-        } else {
-          return {
-            result: global_constants.SCORM_FALSE,
-            errorCode: 101,
-          };
-        }
-      } else {
-        return {
-          result: httpResult.result,
-          errorCode: httpResult.errorCode
-            ? httpResult.errorCode
-            : httpResult.result === global_constants.SCORM_TRUE
-              ? 0
-              : 101,
-        };
-      }
-    }
-    return {
-      result: global_constants.SCORM_FALSE,
-      errorCode: 101,
-    };
-  },
-  requestHandler: function (commitObject) {
-    return commitObject;
-  },
-  onLogMessage: function (messageLevel, logMessage) {
-    switch (messageLevel) {
-      case global_constants.LOG_LEVEL_ERROR:
-        console.error(logMessage);
-        break;
-      case global_constants.LOG_LEVEL_WARNING:
-        console.warn(logMessage);
-        break;
-      case global_constants.LOG_LEVEL_INFO:
-        console.info(logMessage);
-        break;
-      case global_constants.LOG_LEVEL_DEBUG:
-        if (console.debug) {
-          console.debug(logMessage);
-        } else {
-          console.log(logMessage);
-        }
-        break;
-    }
-  },
-};
+import { formatMessage, stringMatches, unflatten } from "./utilities";
+import { BaseCMI } from "./cmi/common/base_cmi";
+import { debounce } from "./utilities/debounce";
+import {
+  RefObject,
+  CommitObject,
+  ResultObject,
+  Settings,
+} from "./types/api_types";
+import { DefaultSettings } from "./constants/default_settings";
+import { IBaseAPI } from "./interfaces/IBaseAPI";
+import { ScheduledCommit } from "./helpers/scheduled_commit";
 
 /**
  * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered
  * abstract, and never initialized on its own.
  */
-export default abstract class BaseAPI {
+export default abstract class BaseAPI implements IBaseAPI {
   private _timeout?: ScheduledCommit;
   private readonly _error_codes: ErrorCode;
   private _settings: Settings = DefaultSettings;
@@ -163,7 +34,7 @@ export default abstract class BaseAPI {
     if (new.target === BaseAPI) {
       throw new TypeError("Cannot construct BaseAPI instances directly");
     }
-    this.currentState = global_constants.STATE_NOT_INITIALIZED;
+    this.currentState = APIConstants.global.STATE_NOT_INITIALIZED;
     this.lastErrorCode = "0";
     this.listenerArray = [];
 
@@ -185,6 +56,21 @@ export default abstract class BaseAPI {
   public apiLogLevel: number;
   public selfReportSessionTime: boolean;
 
+  abstract reset(settings?: Settings): void;
+
+  /**
+   * Common reset method for all APIs. New settings are merged with the existing settings.
+   * @param {Settings} settings
+   * @protected
+   */
+  commonReset(settings?: Settings): void {
+    this.settings = { ...this.settings, ...settings };
+
+    this.currentState = APIConstants.global.STATE_NOT_INITIALIZED;
+    this.lastErrorCode = "0";
+    this.listenerArray = [];
+  }
+
   /**
    * Initialize the API
    * @param {string} callbackName
@@ -197,7 +83,7 @@ export default abstract class BaseAPI {
     initializeMessage?: string,
     terminationMessage?: string,
   ): string {
-    let returnValue = global_constants.SCORM_FALSE;
+    let returnValue = APIConstants.global.SCORM_FALSE;
 
     if (this.isInitialized()) {
       this.throwSCORMError(this._error_codes.INITIALIZED, initializeMessage);
@@ -208,16 +94,16 @@ export default abstract class BaseAPI {
         this.cmi.setStartTime();
       }
 
-      this.currentState = global_constants.STATE_INITIALIZED;
+      this.currentState = APIConstants.global.STATE_INITIALIZED;
       this.lastErrorCode = "0";
-      returnValue = global_constants.SCORM_TRUE;
+      returnValue = APIConstants.global.SCORM_TRUE;
       this.processListeners(callbackName);
     }
 
     this.apiLog(
       callbackName,
       "returned: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
     );
     this.clearSCORMError(returnValue);
 
@@ -240,6 +126,78 @@ export default abstract class BaseAPI {
 
   abstract lmsGetDiagnostic(CMIErrorCode: string | number): string;
 
+  /**
+   * Abstract method for validating that a response is correct.
+   *
+   * @param {string} _CMIElement
+   * @param {any} _value
+   */
+  abstract validateCorrectResponse(_CMIElement: string, _value: any): void;
+
+  /**
+   * Gets or builds a new child element to add to the array.
+   * APIs that inherit BaseAPI should override this method.
+   *
+   * @param {string} _CMIElement - unused
+   * @param {*} _value - unused
+   * @param {boolean} _foundFirstIndex - unused
+   * @return {BaseCMI|null}
+   * @abstract
+   */
+  abstract getChildElement(
+    _CMIElement: string,
+    _value: any,
+    _foundFirstIndex: boolean,
+  ): BaseCMI | null;
+
+  /**
+   * Attempts to store the data to the LMS, logs data if no LMS configured
+   * APIs that inherit BaseAPI should override this function
+   *
+   * @param {boolean} _calculateTotalTime
+   * @return {ResultObject}
+   * @abstract
+   */
+  abstract storeData(_calculateTotalTime: boolean): Promise<ResultObject>;
+
+  /**
+   * Render the cmi object to the proper format for LMS commit
+   * APIs that inherit BaseAPI should override this function
+   *
+   * @param {boolean} _terminateCommit
+   * @return {RefObject|Array}
+   * @abstract
+   */
+  abstract renderCommitCMI(_terminateCommit: boolean): RefObject | Array<any>;
+
+  /**
+   * Render the commit object to the shortened format for LMS commit
+   * @param {boolean} _terminateCommit
+   * @return {CommitObject}
+   */
+  abstract renderCommitObject(_terminateCommit: boolean): CommitObject;
+
+  /**
+   * Logging for all SCORM actions
+   *
+   * @param {string} functionName
+   * @param {string} logMessage
+   * @param {number} messageLevel
+   * @param {string} CMIElement
+   */
+  apiLog(
+    functionName: string,
+    logMessage: string,
+    messageLevel: number,
+    CMIElement?: string,
+  ) {
+    logMessage = formatMessage(functionName, logMessage, CMIElement);
+
+    if (messageLevel >= this.apiLogLevel) {
+      this.settings.onLogMessage(messageLevel, logMessage);
+    }
+  }
+
   /**
    * Getter for _error_codes
    * @return {ErrorCode}
@@ -270,8 +228,11 @@ export default abstract class BaseAPI {
    * @param {boolean} checkTerminated
    * @return {string}
    */
-  terminate(callbackName: string, checkTerminated: boolean): string {
-    let returnValue = global_constants.SCORM_FALSE;
+  async terminate(
+    callbackName: string,
+    checkTerminated: boolean,
+  ): Promise<string> {
+    let returnValue = APIConstants.global.SCORM_FALSE;
 
     if (
       this.checkState(
@@ -280,27 +241,27 @@ export default abstract class BaseAPI {
         this._error_codes.MULTIPLE_TERMINATION,
       )
     ) {
-      this.currentState = global_constants.STATE_TERMINATED;
+      this.currentState = APIConstants.global.STATE_TERMINATED;
 
-      const result: ResultObject = this.storeData(true);
+      const result: ResultObject = await this.storeData(true);
       if (typeof result.errorCode !== "undefined" && result.errorCode > 0) {
         this.throwSCORMError(result.errorCode);
       }
       returnValue =
         typeof result !== "undefined" && result.result
           ? result.result
-          : global_constants.SCORM_FALSE;
+          : APIConstants.global.SCORM_FALSE;
 
       if (checkTerminated) this.lastErrorCode = "0";
 
-      returnValue = global_constants.SCORM_TRUE;
+      returnValue = APIConstants.global.SCORM_TRUE;
       this.processListeners(callbackName);
     }
 
     this.apiLog(
       callbackName,
       "returned: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
     );
     this.clearSCORMError(returnValue);
 
@@ -341,9 +302,14 @@ export default abstract class BaseAPI {
     this.apiLog(
       callbackName,
       ": returned: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
       CMIElement,
     );
+
+    if (returnValue === undefined) {
+      return "";
+    }
+
     this.clearSCORMError(returnValue);
 
     return returnValue;
@@ -369,7 +335,7 @@ export default abstract class BaseAPI {
     if (value !== undefined) {
       value = String(value);
     }
-    let returnValue: string = global_constants.SCORM_FALSE;
+    let returnValue: string = APIConstants.global.SCORM_FALSE;
 
     if (
       this.checkState(
@@ -388,7 +354,7 @@ export default abstract class BaseAPI {
     }
 
     if (returnValue === undefined) {
-      returnValue = global_constants.SCORM_FALSE;
+      returnValue = APIConstants.global.SCORM_FALSE;
     }
 
     // If we didn't have any errors while setting the data, go ahead and
@@ -405,7 +371,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       callbackName,
       ": " + value + ": result: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
       CMIElement,
     );
     this.clearSCORMError(returnValue);
@@ -419,10 +385,13 @@ export default abstract class BaseAPI {
    * @param {boolean} checkTerminated
    * @return {string}
    */
-  commit(callbackName: string, checkTerminated: boolean = false): string {
+  async commit(
+    callbackName: string,
+    checkTerminated: boolean = false,
+  ): Promise<string> {
     this.clearScheduledCommit();
 
-    let returnValue = global_constants.SCORM_FALSE;
+    let returnValue = APIConstants.global.SCORM_FALSE;
 
     if (
       this.checkState(
@@ -431,19 +400,19 @@ export default abstract class BaseAPI {
         this._error_codes.COMMIT_AFTER_TERM,
       )
     ) {
-      const result = this.storeData(false);
+      const result = await this.storeData(false);
       if (result.errorCode && result.errorCode > 0) {
         this.throwSCORMError(result.errorCode);
       }
       returnValue =
         typeof result !== "undefined" && result.result
           ? result.result
-          : global_constants.SCORM_FALSE;
+          : APIConstants.global.SCORM_FALSE;
 
       this.apiLog(
         callbackName,
         " Result: " + returnValue,
-        global_constants.LOG_LEVEL_DEBUG,
+        APIConstants.global.LOG_LEVEL_DEBUG,
         "HttpRequest",
       );
 
@@ -455,7 +424,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       callbackName,
       "returned: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
     );
     this.clearSCORMError(returnValue);
 
@@ -475,7 +444,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       callbackName,
       "returned: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
     );
 
     return returnValue;
@@ -499,7 +468,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       callbackName,
       "returned: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
     );
 
     return returnValue;
@@ -523,7 +492,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       callbackName,
       "returned: " + returnValue,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
     );
 
     return returnValue;
@@ -553,104 +522,6 @@ export default abstract class BaseAPI {
     return true;
   }
 
-  /**
-   * Logging for all SCORM actions
-   *
-   * @param {string} functionName
-   * @param {string} logMessage
-   * @param {number}messageLevel
-   * @param {string} CMIElement
-   */
-  apiLog(
-    functionName: string,
-    logMessage: string,
-    messageLevel: number,
-    CMIElement?: string,
-  ) {
-    logMessage = this.formatMessage(functionName, logMessage, CMIElement);
-
-    if (messageLevel >= this.apiLogLevel) {
-      this.settings.onLogMessage(messageLevel, logMessage);
-    }
-  }
-
-  /**
-   * Formats the SCORM messages for easy reading
-   *
-   * @param {string} functionName
-   * @param {string} message
-   * @param {string} CMIElement
-   * @return {string}
-   */
-  formatMessage(
-    functionName: string,
-    message: string,
-    CMIElement?: string,
-  ): string {
-    const baseLength = 20;
-    let messageString = "";
-
-    messageString += functionName;
-
-    let fillChars = baseLength - messageString.length;
-
-    for (let i = 0; i < fillChars; i++) {
-      messageString += " ";
-    }
-
-    messageString += ": ";
-
-    if (CMIElement) {
-      const CMIElementBaseLength = 70;
-
-      messageString += CMIElement;
-
-      fillChars = CMIElementBaseLength - messageString.length;
-
-      for (let j = 0; j < fillChars; j++) {
-        messageString += " ";
-      }
-    }
-
-    if (message) {
-      messageString += message;
-    }
-
-    return messageString;
-  }
-
-  /**
-   * Checks to see if {str} contains {tester}
-   *
-   * @param {string} str String to check against
-   * @param {string} tester String to check for
-   * @return {boolean}
-   */
-  stringMatches(str: string, tester: string): boolean {
-    return str?.match(tester) !== null;
-  }
-
-  /**
-   * Check to see if the specific object has the given property
-   * @param {RefObject} refObject
-   * @param {string} attribute
-   * @return {boolean}
-   * @private
-   */
-  private _checkObjectHasProperty(
-    refObject: RefObject,
-    attribute: string,
-  ): boolean {
-    return (
-      Object.hasOwnProperty.call(refObject, attribute) ||
-      Object.getOwnPropertyDescriptor(
-        Object.getPrototypeOf(refObject),
-        attribute,
-      ) != null ||
-      attribute in refObject
-    );
-  }
-
   /**
    * Returns the message that corresponds to errorNumber
    * APIs that inherit BaseAPI should override this function
@@ -710,12 +581,12 @@ export default abstract class BaseAPI {
     value: any,
   ): string {
     if (!CMIElement || CMIElement === "") {
-      return global_constants.SCORM_FALSE;
+      return APIConstants.global.SCORM_FALSE;
     }
 
     const structure = CMIElement.split(".");
     let refObject: RefObject = this;
-    let returnValue = global_constants.SCORM_FALSE;
+    let returnValue = APIConstants.global.SCORM_FALSE;
     let foundFirstIndex = false;
 
     const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;
@@ -727,25 +598,28 @@ export default abstract class BaseAPI {
       const attribute = structure[idx];
 
       if (idx === structure.length - 1) {
-        if (
-          scorm2004 &&
-          attribute.substring(0, 8) === "{target=" &&
-          typeof refObject._isTargetValid == "function"
-        ) {
-          this.throwSCORMError(this._error_codes.READ_ONLY_ELEMENT);
+        if (scorm2004 && attribute.substring(0, 8) === "{target=") {
+          if (this.isInitialized()) {
+            this.throwSCORMError(this._error_codes.READ_ONLY_ELEMENT);
+          } else {
+            refObject = {
+              ...refObject,
+              attribute: value,
+            };
+          }
         } else if (!this._checkObjectHasProperty(refObject, attribute)) {
           this.throwSCORMError(invalidErrorCode, invalidErrorMessage);
         } else {
           if (
-            this.isInitialized() &&
-            this.stringMatches(CMIElement, "\\.correct_responses\\.\\d+")
+            stringMatches(CMIElement, "\\.correct_responses\\.\\d+") &&
+            this.isInitialized()
           ) {
             this.validateCorrectResponse(CMIElement, value);
           }
 
           if (!scorm2004 || this.lastErrorCode === "0") {
             refObject[attribute] = value;
-            returnValue = global_constants.SCORM_TRUE;
+            returnValue = APIConstants.global.SCORM_TRUE;
           }
         }
       } else {
@@ -790,41 +664,17 @@ export default abstract class BaseAPI {
       }
     }
 
-    if (returnValue === global_constants.SCORM_FALSE) {
+    if (returnValue === APIConstants.global.SCORM_FALSE) {
       this.apiLog(
         methodName,
         `There was an error setting the value for: ${CMIElement}, value of: ${value}`,
-        global_constants.LOG_LEVEL_WARNING,
+        APIConstants.global.LOG_LEVEL_WARNING,
       );
     }
 
     return returnValue;
   }
 
-  /**
-   * Abstract method for validating that a response is correct.
-   *
-   * @param {string} _CMIElement
-   * @param {any} _value
-   */
-  abstract validateCorrectResponse(_CMIElement: string, _value: any): void;
-
-  /**
-   * Gets or builds a new child element to add to the array.
-   * APIs that inherit BaseAPI should override this method.
-   *
-   * @param {string} _CMIElement - unused
-   * @param {*} _value - unused
-   * @param {boolean} _foundFirstIndex - unused
-   * @return {BaseCMI|null}
-   * @abstract
-   */
-  abstract getChildElement(
-    _CMIElement: string,
-    _value: any,
-    _foundFirstIndex: boolean,
-  ): BaseCMI | null;
-
   /**
    * Gets a value from the CMI Object
    *
@@ -910,9 +760,9 @@ export default abstract class BaseAPI {
     if (refObject === null || refObject === undefined) {
       if (!scorm2004) {
         if (attribute === "_children") {
-          this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);
+          this.throwSCORMError(ErrorCodes.scorm12.CHILDREN_ERROR);
         } else if (attribute === "_count") {
-          this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);
+          this.throwSCORMError(ErrorCodes.scorm12.COUNT_ERROR);
         }
       }
     } else {
@@ -926,7 +776,7 @@ export default abstract class BaseAPI {
    * @return {boolean}
    */
   isInitialized(): boolean {
-    return this.currentState === global_constants.STATE_INITIALIZED;
+    return this.currentState === APIConstants.global.STATE_INITIALIZED;
   }
 
   /**
@@ -935,7 +785,7 @@ export default abstract class BaseAPI {
    * @return {boolean}
    */
   isNotInitialized(): boolean {
-    return this.currentState === global_constants.STATE_NOT_INITIALIZED;
+    return this.currentState === APIConstants.global.STATE_NOT_INITIALIZED;
   }
 
   /**
@@ -944,7 +794,7 @@ export default abstract class BaseAPI {
    * @return {boolean}
    */
   isTerminated(): boolean {
-    return this.currentState === global_constants.STATE_TERMINATED;
+    return this.currentState === APIConstants.global.STATE_TERMINATED;
   }
 
   /**
@@ -977,7 +827,7 @@ export default abstract class BaseAPI {
       this.apiLog(
         "on",
         `Added event listener: ${this.listenerArray.length}`,
-        global_constants.LOG_LEVEL_INFO,
+        APIConstants.global.LOG_LEVEL_INFO,
         functionName,
       );
     }
@@ -1015,7 +865,7 @@ export default abstract class BaseAPI {
         this.apiLog(
           "off",
           `Removed event listener: ${this.listenerArray.length}`,
-          global_constants.LOG_LEVEL_INFO,
+          APIConstants.global.LOG_LEVEL_INFO,
           functionName,
         );
       }
@@ -1058,7 +908,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       functionName,
       value,
-      global_constants.LOG_LEVEL_INFO,
+      APIConstants.global.LOG_LEVEL_INFO,
       CMIElement,
     );
     for (let i = 0; i < this.listenerArray.length; i++) {
@@ -1083,7 +933,7 @@ export default abstract class BaseAPI {
         this.apiLog(
           "processListeners",
           `Processing listener: ${listener.functionName}`,
-          global_constants.LOG_LEVEL_INFO,
+          APIConstants.global.LOG_LEVEL_INFO,
           CMIElement,
         );
         listener.callback(CMIElement, value);
@@ -1105,7 +955,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       "throwSCORMError",
       errorNumber + ": " + message,
-      global_constants.LOG_LEVEL_ERROR,
+      APIConstants.global.LOG_LEVEL_ERROR,
     );
 
     this.lastErrorCode = String(errorNumber);
@@ -1117,27 +967,21 @@ export default abstract class BaseAPI {
    * @param {string} success
    */
   clearSCORMError(success: string) {
-    if (success !== undefined && success !== global_constants.SCORM_FALSE) {
+    if (success !== undefined && success !== APIConstants.global.SCORM_FALSE) {
       this.lastErrorCode = "0";
     }
   }
 
-  /**
-   * Attempts to store the data to the LMS, logs data if no LMS configured
-   * APIs that inherit BaseAPI should override this function
-   *
-   * @param {boolean} _calculateTotalTime
-   * @return {ResultObject}
-   * @abstract
-   */
-  abstract storeData(_calculateTotalTime: boolean): ResultObject;
-
   /**
    * Load the CMI from a flattened JSON object
    * @param {RefObject} json
    * @param {string} CMIElement
    */
-  loadFromFlattenedJSON(json: RefObject, CMIElement: string) {
+  loadFromFlattenedJSON(json: RefObject, CMIElement?: string) {
+    if (!CMIElement) {
+      // by default, we start from a blank string because we're expecting each element to start with `cmi`
+      CMIElement = "";
+    }
     if (!this.isNotInitialized()) {
       console.error(
         "loadFromFlattenedJSON can only be called before the call to lmsInitialize.",
@@ -1146,12 +990,12 @@ export default abstract class BaseAPI {
     }
 
     /**
-     * Test match pattern.
+     * Tests two strings against a given regular expression pattern and determines a numeric or null result based on the matching criterion.
      *
-     * @param {string} a
-     * @param {string} c
-     * @param {RegExp} a_pattern
-     * @return {number}
+     * @param {string} a - The first string to be tested against the pattern.
+     * @param {string} c - The second string to be tested against the pattern.
+     * @param {RegExp} a_pattern - The regular expression pattern to test the strings against.
+     * @return {number | null} A numeric result based on the matching criterion, or null if the strings do not match the pattern.
      */
     function testPattern(
       a: string,
@@ -1265,8 +1109,10 @@ export default abstract class BaseAPI {
   renderCMIToJSONString(): string {
     const cmi = this.cmi;
     // Do we want/need to return fields that have no set value?
-    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);
-    return JSON.stringify({ cmi });
+    if (this.settings.sendFullCommit) {
+      return JSON.stringify({ cmi });
+    }
+    return JSON.stringify({ cmi }, (k, v) => (v === undefined ? null : v), 2);
   }
 
   /**
@@ -1274,89 +1120,71 @@ export default abstract class BaseAPI {
    * @return {object}
    */
   renderCMIToJSONObject(): object {
-    // Do we want/need to return fields that have no set value?
-    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);
     return JSON.parse(this.renderCMIToJSONString());
   }
 
-  /**
-   * Render the cmi object to the proper format for LMS commit
-   * APIs that inherit BaseAPI should override this function
-   *
-   * @param {boolean} _terminateCommit
-   * @return {RefObject|Array}
-   * @abstract
-   */
-  abstract renderCommitCMI(_terminateCommit: boolean): RefObject | Array<any>;
-
   /**
    * Send the request to the LMS
    * @param {string} url
-   * @param {RefObject|Array} params
+   * @param {CommitObject|RefObject|Array} params
    * @param {boolean} immediate
    * @return {ResultObject}
    */
-  processHttpRequest(
+  async processHttpRequest(
     url: string,
-    params: RefObject | Array<any>,
+    params: CommitObject | RefObject | Array<any>,
     immediate: boolean = false,
-  ): ResultObject {
+  ): Promise<ResultObject> {
     const api = this;
     const genericError: ResultObject = {
-      result: global_constants.SCORM_FALSE,
+      result: APIConstants.global.SCORM_FALSE,
       errorCode: this.error_codes.GENERAL,
     };
 
+    // 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) {
+      this.performFetch(url, params).then(async (response) => {
+        await this.transformResponse(response);
+      });
+      return {
+        result: APIConstants.global.SCORM_TRUE,
+        errorCode: 0,
+      };
+    }
+
     const process = async (
       url: string,
-      params: RefObject | Array<any>,
+      params: CommitObject | RefObject | Array<any>,
       settings: Settings,
     ): Promise<ResultObject> => {
       try {
         params = settings.requestHandler(params);
-        const response = await fetch(url, {
-          method: "POST",
-          body:
-            params instanceof Array ? params.join("&") : JSON.stringify(params),
-          headers: {
-            ...settings.xhrHeaders,
-            "Content-Type": settings.commitRequestDataType,
-          },
-          credentials: settings.xhrWithCredentials ? "include" : undefined,
-          keepalive: true,
-        });
-
-        const result =
-          typeof settings.responseHandler === "function"
-            ? await settings.responseHandler(response)
-            : await response.json();
+        const response = await this.performFetch(url, params);
 
-        if (
-          response.status >= 200 &&
-          response.status <= 299 &&
-          (result.result === true ||
-            result.result === global_constants.SCORM_TRUE)
-        ) {
-          api.processListeners("CommitSuccess");
-        } else {
-          api.processListeners("CommitError");
-        }
-
-        return result;
+        return this.transformResponse(response);
       } catch (e) {
-        this.apiLog("processHttpRequest", e, global_constants.LOG_LEVEL_ERROR);
+        this.apiLog(
+          "processHttpRequest",
+          e,
+          APIConstants.global.LOG_LEVEL_ERROR,
+        );
         api.processListeners("CommitError");
         return genericError;
       }
     };
 
-    const debouncedProcess = debounce(process, 500, immediate);
-    debouncedProcess(url, params, this.settings);
+    if (this.settings.asyncCommit) {
+      const debouncedProcess = debounce(process, 500, immediate);
+      debouncedProcess(url, params, this.settings);
 
-    return {
-      result: global_constants.SCORM_TRUE,
-      errorCode: 0,
-    };
+      return {
+        result: APIConstants.global.SCORM_TRUE,
+        errorCode: 0,
+      };
+    } else {
+      return await process(url, params, this.settings);
+    }
   }
 
   /**
@@ -1370,7 +1198,7 @@ export default abstract class BaseAPI {
     this.apiLog(
       "scheduleCommit",
       "scheduled",
-      global_constants.LOG_LEVEL_DEBUG,
+      APIConstants.global.LOG_LEVEL_DEBUG,
       "",
     );
   }
@@ -1385,16 +1213,44 @@ export default abstract class BaseAPI {
       this.apiLog(
         "clearScheduledCommit",
         "cleared",
-        global_constants.LOG_LEVEL_DEBUG,
+        APIConstants.global.LOG_LEVEL_DEBUG,
         "",
       );
     }
   }
 
-  private handleValueAccessException(e: any, returnValue: string) {
+  /**
+   * Check to see if the specific object has the given property
+   * @param {RefObject} refObject
+   * @param {string} attribute
+   * @return {boolean}
+   * @private
+   */
+  private _checkObjectHasProperty(
+    refObject: RefObject,
+    attribute: string,
+  ): boolean {
+    return (
+      Object.hasOwnProperty.call(refObject, attribute) ||
+      Object.getOwnPropertyDescriptor(
+        Object.getPrototypeOf(refObject),
+        attribute,
+      ) != null ||
+      attribute in refObject
+    );
+  }
+
+  /**
+   * Handles the error that occurs when trying to access a value
+   * @param {any} e
+   * @param {string} returnValue
+   * @return {string}
+   * @private
+   */
+  private handleValueAccessException(e: any, returnValue: string): string {
     if (e instanceof ValidationError) {
       this.lastErrorCode = String(e.errorCode);
-      returnValue = global_constants.SCORM_FALSE;
+      returnValue = APIConstants.global.SCORM_FALSE;
     } else {
       if (e instanceof Error && e.message) {
         console.error(e.message);
@@ -1405,45 +1261,52 @@ export default abstract class BaseAPI {
     }
     return returnValue;
   }
-}
-
-/**
- * Private class that wraps a timeout call to the commit() function
- */
-class ScheduledCommit {
-  private _API;
-  private _cancelled = false;
-  private readonly _timeout;
-  private readonly _callback;
 
   /**
-   * Constructor for ScheduledCommit
-   * @param {BaseAPI} API
-   * @param {number} when
-   * @param {string} callback
+   * Perform the fetch request to the LMS
+   * @param {string} url
+   * @param {RefObject|Array} params
+   * @return {Promise<Response>}
+   * @private
    */
-  constructor(API: any, when: number, callback: string) {
-    this._API = API;
-    this._timeout = setTimeout(this.wrapper.bind(this), when);
-    this._callback = callback;
+  private async performFetch(
+    url: string,
+    params: RefObject | Array<any>,
+  ): Promise<Response> {
+    return fetch(url, {
+      method: "POST",
+      body: params instanceof Array ? params.join("&") : JSON.stringify(params),
+      headers: {
+        ...this.settings.xhrHeaders,
+        "Content-Type": this.settings.commitRequestDataType,
+      },
+      credentials: this.settings.xhrWithCredentials ? "include" : undefined,
+      keepalive: true,
+    });
   }
 
   /**
-   * Cancel any currently scheduled commit
+   * Transforms the response from the LMS to a ResultObject
+   * @param {Response} response
+   * @return {Promise<ResultObject>}
+   * @private
    */
-  cancel() {
-    this._cancelled = true;
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-    }
-  }
+  private async transformResponse(response: Response): Promise<ResultObject> {
+    const result =
+      typeof this.settings.responseHandler === "function"
+        ? await this.settings.responseHandler(response)
+        : await response.json();
 
-  /**
-   * Wrap the API commit call to check if the call has already been cancelled
-   */
-  wrapper() {
-    if (!this._cancelled) {
-      this._API.commit(this._callback);
+    if (
+      response.status >= 200 &&
+      response.status <= 299 &&
+      (result.result === true ||
+        result.result === APIConstants.global.SCORM_TRUE)
+    ) {
+      this.processListeners("CommitSuccess");
+    } else {
+      this.processListeners("CommitError");
     }
+    return result;
   }
 }