scorm-again 1.7.0 → 2.0.0

package/src/{Scorm2004API.js → Scorm2004API.ts}

@@ -1,5 +1,4 @@
-// @flow
-import BaseAPI from './BaseAPI';
+import BaseAPI, { RefObject, ResultObject, Settings } from "./BaseAPI";
 import {
   ADL,
   CMI,
@@ -8,45 +7,46 @@ import {
   CMIInteractionsObject,
   CMIInteractionsObjectivesObject,
   CMIObjectivesObject,
-} from './cmi/scorm2004_cmi';
-import * as Utilities from './utilities';
-import APIConstants from './constants/api_constants';
-import ErrorCodes from './constants/error_codes';
-import Responses from './constants/response_constants';
-import ValidLanguages from './constants/language_constants';
-import Regex from './constants/regex';
+} from "./cmi/scorm2004_cmi";
+import * as Utilities from "./utilities";
+import APIConstants from "./constants/api_constants";
+import ErrorCodes from "./constants/error_codes";
+import { CorrectResponses, ResponseType } from "./constants/response_constants";
+import ValidLanguages from "./constants/language_constants";
+import Regex from "./constants/regex";
+import { BaseCMI, CMIArray } from "./cmi/common";
 
 const scorm2004_constants = APIConstants.scorm2004;
 const global_constants = APIConstants.global;
 const scorm2004_error_codes = ErrorCodes.scorm2004;
-const correct_responses = Responses.correct;
+const correct_responses = CorrectResponses;
 const scorm2004_regex = Regex.scorm2004;
 
 /**
  * API class for SCORM 2004
  */
 export default class Scorm2004API extends BaseAPI {
-  #version: '1.0';
+  private _version: string = "1.0";
 
   /**
    * Constructor for SCORM 2004 API
-   * @param {object} settings
+   * @param {Settings} settings
    */
-  constructor(settings: {}) {
-    const finalSettings = {
-      ...{
-        mastery_override: false,
-      }, ...settings,
-    };
+  constructor(settings?: Settings) {
+    if (settings) {
+      if (settings.mastery_override === undefined) {
+        settings.mastery_override = false;
+      }
+    }
 
-    super(scorm2004_error_codes, finalSettings);
+    super(scorm2004_error_codes, settings);
 
     this.cmi = new CMI();
     this.adl = new ADL();
 
     // Rename functions to match 2004 Spec and expose to modules
     this.Initialize = this.lmsInitialize;
-    this.Terminate = this.lmsTerminate;
+    this.Terminate = this.lmsFinish;
     this.GetValue = this.lmsGetValue;
     this.SetValue = this.lmsSetValue;
     this.Commit = this.lmsCommit;
@@ -55,55 +55,67 @@ export default class Scorm2004API extends BaseAPI {
     this.GetDiagnostic = this.lmsGetDiagnostic;
   }
 
+  public cmi: CMI;
+  public adl: ADL;
+
+  public Initialize: () => string;
+  public Terminate: () => string;
+  public GetValue: (CMIElement: string) => string;
+  public SetValue: (CMIElement: string, value: any) => string;
+  public Commit: () => string;
+  public GetLastError: () => string;
+  public GetErrorString: (CMIErrorCode: string | number) => string;
+  public GetDiagnostic: (CMIErrorCode: string | number) => string;
+
   /**
-   * Getter for #version
+   * Getter for _version
    * @return {string}
    */
-  get version() {
-    return this.#version;
+  get version(): string {
+    return this._version;
   }
 
   /**
    * @return {string} bool
    */
-  lmsInitialize() {
+  lmsInitialize(): string {
     this.cmi.initialize();
-    return this.initialize('Initialize');
+    return this.initialize("Initialize");
   }
 
   /**
    * @return {string} bool
    */
-  lmsTerminate() {
-    const result = this.terminate('Terminate', true);
+  lmsFinish(): string {
+    const result = this.terminate("Terminate", true);
 
     if (result === global_constants.SCORM_TRUE) {
-      if (this.adl.nav.request !== '_none_') {
+      if (this.adl.nav.request !== "_none_") {
         switch (this.adl.nav.request) {
-          case 'continue':
-            this.processListeners('SequenceNext');
+          case "continue":
+            this.processListeners("SequenceNext");
             break;
-          case 'previous':
-            this.processListeners('SequencePrevious');
+          case "previous":
+            this.processListeners("SequencePrevious");
             break;
-          case 'choice':
-            this.processListeners('SequenceChoice');
+          case "choice":
+            this.processListeners("SequenceChoice");
             break;
-          case 'exit':
-            this.processListeners('SequenceExit');
+          case "exit":
+            this.processListeners("SequenceExit");
             break;
-          case 'exitAll':
-            this.processListeners('SequenceExitAll');
+          case "exitAll":
+            this.processListeners("SequenceExitAll");
             break;
-          case 'abandon':
-            this.processListeners('SequenceAbandon');
+          case "abandon":
+            this.processListeners("SequenceAbandon");
             break;
-          case 'abandonAll':
-            this.processListeners('SequenceAbandonAll');
+          case "abandonAll":
+            this.processListeners("SequenceAbandonAll");
             break;
         }
       } else if (this.settings.autoProgress) {
-        this.processListeners('SequenceNext');
+        this.processListeners("SequenceNext");
       }
     }
 
@@ -114,8 +126,8 @@ export default class Scorm2004API extends BaseAPI {
    * @param {string} CMIElement
    * @return {string}
    */
-  lmsGetValue(CMIElement) {
-    return this.getValue('GetValue', true, CMIElement);
+  lmsGetValue(CMIElement: string): string {
+    return this.getValue("GetValue", true, CMIElement);
   }
 
   /**
@@ -123,8 +135,8 @@ export default class Scorm2004API extends BaseAPI {
    * @param {any} value
    * @return {string}
    */
-  lmsSetValue(CMIElement, value) {
-    return this.setValue('SetValue', 'Commit', true, CMIElement, value);
+  lmsSetValue(CMIElement: string, value: any): string {
+    return this.setValue("SetValue", "Commit", true, CMIElement, value);
   }
 
   /**
@@ -132,8 +144,8 @@ export default class Scorm2004API extends BaseAPI {
    *
    * @return {string} bool
    */
-  lmsCommit() {
-    return this.commit('Commit');
+  lmsCommit(): string {
+    return this.commit("Commit");
   }
 
   /**
@@ -141,8 +153,8 @@ export default class Scorm2004API extends BaseAPI {
    *
    * @return {string}
    */
-  lmsGetLastError() {
-    return this.getLastError('GetLastError');
+  lmsGetLastError(): string {
+    return this.getLastError("GetLastError");
   }
 
   /**
@@ -151,8 +163,8 @@ export default class Scorm2004API extends BaseAPI {
    * @param {(string|number)} CMIErrorCode
    * @return {string}
    */
-  lmsGetErrorString(CMIErrorCode) {
-    return this.getErrorString('GetErrorString', CMIErrorCode);
+  lmsGetErrorString(CMIErrorCode: string | number): string {
+    return this.getErrorString("GetErrorString", CMIErrorCode);
   }
 
   /**
@@ -161,8 +173,8 @@ export default class Scorm2004API extends BaseAPI {
    * @param {(string|number)} CMIErrorCode
    * @return {string}
    */
-  lmsGetDiagnostic(CMIErrorCode) {
-    return this.getDiagnostic('GetDiagnostic', CMIErrorCode);
+  lmsGetDiagnostic(CMIErrorCode: string | number): string {
+    return this.getDiagnostic("GetDiagnostic", CMIErrorCode);
   }
 
   /**
@@ -172,8 +184,8 @@ export default class Scorm2004API extends BaseAPI {
    * @param {any} value
    * @return {string}
    */
-  setCMIValue(CMIElement, value) {
-    return this._commonSetCMIValue('SetValue', true, CMIElement, value);
+  setCMIValue(CMIElement: string, value: any): string {
+    return this._commonSetCMIValue("SetValue", true, CMIElement, value);
   }
 
   /**
@@ -182,22 +194,30 @@ export default class Scorm2004API extends BaseAPI {
    * @param {string} CMIElement
    * @param {any} value
    * @param {boolean} foundFirstIndex
-   * @return {any}
+   * @return {BaseCMI|null}
    */
-  getChildElement(CMIElement, value, foundFirstIndex) {
-    let newChild;
-
-    if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) {
-      newChild = new CMIObjectivesObject();
-    } else if (foundFirstIndex && this.stringMatches(CMIElement,
-        'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) {
-      const parts = CMIElement.split('.');
+  getChildElement(
+    CMIElement: string,
+    value: any,
+    foundFirstIndex: boolean,
+  ): BaseCMI | null {
+    if (this.stringMatches(CMIElement, "cmi\\.objectives\\.\\d+")) {
+      return new CMIObjectivesObject();
+    } else if (
+      foundFirstIndex &&
+      this.stringMatches(
+        CMIElement,
+        "cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+",
+      )
+    ) {
+      const parts = CMIElement.split(".");
       const index = Number(parts[2]);
       const interaction = this.cmi.interactions.childArray[index];
       if (this.isInitialized()) {
         if (!interaction.type) {
           this.throwSCORMError(
-              scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);
+            scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED,
+          );
         } else {
           this.checkDuplicateChoiceResponse(interaction, value);
 
@@ -205,29 +225,40 @@ export default class Scorm2004API extends BaseAPI {
           if (response_type) {
             this.checkValidResponseType(response_type, value, interaction.type);
           } else {
-            this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,
-                'Incorrect Response Type: ' + interaction.type);
+            this.throwSCORMError(
+              scorm2004_error_codes.GENERAL_SET_FAILURE,
+              "Incorrect Response Type: " + interaction.type,
+            );
           }
         }
       }
-      if (this.lastErrorCode === 0) {
-        newChild = new CMIInteractionsCorrectResponsesObject();
+      if (this.lastErrorCode === "0") {
+        return new CMIInteractionsCorrectResponsesObject();
       }
-    } else if (foundFirstIndex && this.stringMatches(CMIElement,
-        'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) {
-      newChild = new CMIInteractionsObjectivesObject();
-    } else if (!foundFirstIndex &&
-        this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) {
-      newChild = new CMIInteractionsObject();
-    } else if (this.stringMatches(CMIElement,
-        'cmi\\.comments_from_learner\\.\\d+')) {
-      newChild = new CMICommentsObject();
-    } else if (this.stringMatches(CMIElement,
-        'cmi\\.comments_from_lms\\.\\d+')) {
-      newChild = new CMICommentsObject(true);
+    } else if (
+      foundFirstIndex &&
+      this.stringMatches(
+        CMIElement,
+        "cmi\\.interactions\\.\\d+\\.objectives\\.\\d+",
+      )
+    ) {
+      return new CMIInteractionsObjectivesObject();
+    } else if (
+      !foundFirstIndex &&
+      this.stringMatches(CMIElement, "cmi\\.interactions\\.\\d+")
+    ) {
+      return new CMIInteractionsObject();
+    } else if (
+      this.stringMatches(CMIElement, "cmi\\.comments_from_learner\\.\\d+")
+    ) {
+      return new CMICommentsObject();
+    } else if (
+      this.stringMatches(CMIElement, "cmi\\.comments_from_lms\\.\\d+")
+    ) {
+      return new CMICommentsObject(true);
     }
 
-    return newChild;
+    return null;
   }
 
   /**
@@ -236,7 +267,11 @@ export default class Scorm2004API extends BaseAPI {
    * @param {any} value
    * @param {string} interaction_type
    */
-  checkValidResponseType(response_type, value, interaction_type) {
+  checkValidResponseType(
+    response_type: ResponseType,
+    value: any,
+    interaction_type: string,
+  ) {
     let nodes = [];
     if (response_type?.delimiter) {
       nodes = String(value).split(response_type.delimiter);
@@ -247,8 +282,10 @@ export default class Scorm2004API extends BaseAPI {
     if (nodes.length > 0 && nodes.length <= response_type.max) {
       this.checkCorrectResponseValue(interaction_type, nodes, value);
     } else if (nodes.length > response_type.max) {
-      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,
-          'Data Model Element Pattern Too Long');
+      this.throwSCORMError(
+        scorm2004_error_codes.GENERAL_SET_FAILURE,
+        "Data Model Element Pattern Too Long",
+      );
     }
   }
 
@@ -257,11 +294,14 @@ export default class Scorm2004API extends BaseAPI {
    * @param {CMIInteractionsObject} interaction
    * @param {any} value
    */
-  checkDuplicateChoiceResponse(interaction, value) {
+  checkDuplicateChoiceResponse(interaction: CMIInteractionsObject, value: any) {
     const interaction_count = interaction.correct_responses._count;
-    if (interaction.type === 'choice') {
-      for (let i = 0; i < interaction_count && this.lastErrorCode ===
-      0; i++) {
+    if (interaction.type === "choice") {
+      for (
+        let i = 0;
+        i < interaction_count && this.lastErrorCode === "0";
+        i++
+      ) {
         const response = interaction.correct_responses.childArray[i];
         if (response.pattern === value) {
           this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE);
@@ -275,8 +315,8 @@ export default class Scorm2004API extends BaseAPI {
    * @param {string} CMIElement
    * @param {*} value
    */
-  validateCorrectResponse(CMIElement, value) {
-    const parts = CMIElement.split('.');
+  validateCorrectResponse(CMIElement: string, value: any) {
+    const parts = CMIElement.split(".");
     const index = Number(parts[2]);
     const pattern_index = Number(parts[4]);
     const interaction = this.cmi.interactions.childArray[index];
@@ -285,25 +325,36 @@ export default class Scorm2004API extends BaseAPI {
     this.checkDuplicateChoiceResponse(interaction, value);
 
     const response_type = correct_responses[interaction.type];
-    if (typeof response_type.limit === 'undefined' || interaction_count <=
-        response_type.limit) {
+    if (
+      typeof response_type.limit === "undefined" ||
+      interaction_count <= response_type.limit
+    ) {
       this.checkValidResponseType(response_type, value, interaction.type);
 
-      if (this.lastErrorCode === 0 &&
+      if (
+        (this.lastErrorCode === "0" &&
           (!response_type.duplicate ||
-              !this.checkDuplicatedPattern(interaction.correct_responses,
-                  pattern_index, value)) ||
-          (this.lastErrorCode === 0 && value === '')) {
+            !this.checkDuplicatedPattern(
+              interaction.correct_responses,
+              pattern_index,
+              value,
+            ))) ||
+        (this.lastErrorCode === "0" && value === "")
+      ) {
         // do nothing, we want the inverse
       } else {
-        if (this.lastErrorCode === 0) {
-          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,
-              'Data Model Element Pattern Already Exists');
+        if (this.lastErrorCode === "0") {
+          this.throwSCORMError(
+            scorm2004_error_codes.GENERAL_SET_FAILURE,
+            "Data Model Element Pattern Already Exists",
+          );
         }
       }
     } else {
-      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,
-          'Data Model Element Collection Limit Reached');
+      this.throwSCORMError(
+        scorm2004_error_codes.GENERAL_SET_FAILURE,
+        "Data Model Element Collection Limit Reached",
+      );
     }
   }
 
@@ -313,8 +364,8 @@ export default class Scorm2004API extends BaseAPI {
    * @param {string} CMIElement
    * @return {*}
    */
-  getCMIValue(CMIElement) {
-    return this._commonGetCMIValue('GetValue', true, CMIElement);
+  getCMIValue(CMIElement: string): any {
+    return this._commonGetCMIValue("GetValue", true, CMIElement);
   }
 
   /**
@@ -324,15 +375,20 @@ export default class Scorm2004API extends BaseAPI {
    * @param {boolean} detail
    * @return {string}
    */
-  getLmsErrorMessageDetails(errorNumber, detail) {
-    let basicMessage = '';
-    let detailMessage = '';
+  getLmsErrorMessageDetails(
+    errorNumber: string | number,
+    detail: boolean,
+  ): string {
+    let basicMessage = "";
+    let detailMessage = "";
 
     // Set error number to string since inconsistent from modules if string or number
     errorNumber = String(errorNumber);
     if (scorm2004_constants.error_descriptions[errorNumber]) {
-      basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage;
-      detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage;
+      basicMessage =
+        scorm2004_constants.error_descriptions[errorNumber].basicMessage;
+      detailMessage =
+        scorm2004_constants.error_descriptions[errorNumber].detailMessage;
     }
 
     return detail ? detailMessage : basicMessage;
@@ -345,7 +401,11 @@ export default class Scorm2004API extends BaseAPI {
    * @param {*} value
    * @return {boolean}
    */
-  checkDuplicatedPattern = (correct_response, current_index, value) => {
+  checkDuplicatedPattern(
+    correct_response: CMIArray,
+    current_index: number,
+    value: any,
+  ): boolean {
     let found = false;
     const count = correct_response._count;
     for (let i = 0; i < count && !found; i++) {
@@ -354,7 +414,7 @@ export default class Scorm2004API extends BaseAPI {
       }
     }
     return found;
-  };
+  }
 
   /**
    * Checks for a valid correct_response value
@@ -362,12 +422,19 @@ export default class Scorm2004API extends BaseAPI {
    * @param {Array} nodes
    * @param {*} value
    */
-  checkCorrectResponseValue(interaction_type, nodes, value) {
+  checkCorrectResponseValue(
+    interaction_type: string,
+    nodes: Array<any>,
+    value: any,
+  ) {
     const response = correct_responses[interaction_type];
     const formatRegex = new RegExp(response.format);
-    for (let i = 0; i < nodes.length && this.lastErrorCode === 0; i++) {
-      if (interaction_type.match(
-          '^(fill-in|long-fill-in|matching|performance|sequencing)$')) {
+    for (let i = 0; i < nodes.length && this.lastErrorCode === "0"; i++) {
+      if (
+        interaction_type.match(
+          "^(fill-in|long-fill-in|matching|performance|sequencing)$",
+        )
+      ) {
         nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]);
       }
 
@@ -378,7 +445,10 @@ export default class Scorm2004API extends BaseAPI {
           if (!matches) {
             this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
           } else {
-            if (!values[1].match(new RegExp(response.format2))) {
+            if (
+              !response.format2 ||
+              !values[1].match(new RegExp(response.format2))
+            ) {
               this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
             }
           }
@@ -387,17 +457,19 @@ export default class Scorm2004API extends BaseAPI {
         }
       } else {
         const matches = nodes[i].match(formatRegex);
-        if ((!matches && value !== '') ||
-            (!matches && interaction_type === 'true-false')) {
+        if (
+          (!matches && value !== "") ||
+          (!matches && interaction_type === "true-false")
+        ) {
           this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
         } else {
-          if (interaction_type === 'numeric' && nodes.length > 1) {
+          if (interaction_type === "numeric" && nodes.length > 1) {
             if (Number(nodes[0]) > Number(nodes[1])) {
               this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
             }
           } else {
-            if (nodes[i] !== '' && response.unique) {
-              for (let j = 0; j < i && this.lastErrorCode === 0; j++) {
+            if (nodes[i] !== "" && response.unique) {
+              for (let j = 0; j < i && this.lastErrorCode === "0"; j++) {
                 if (nodes[i] === nodes[j]) {
                   this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
                 }
@@ -414,41 +486,42 @@ export default class Scorm2004API extends BaseAPI {
    * @param {string} node
    * @return {*}
    */
-  removeCorrectResponsePrefixes(node) {
+  removeCorrectResponsePrefixes(node: string): any {
     let seenOrder = false;
     let seenCase = false;
     let seenLang = false;
 
     const prefixRegex = new RegExp(
-        '^({(lang|case_matters|order_matters)=([^}]+)})');
+      "^({(lang|case_matters|order_matters)=([^}]+)})",
+    );
     let matches = node.match(prefixRegex);
     let langMatches = null;
     while (matches) {
       switch (matches[2]) {
-        case 'lang':
+        case "lang":
           langMatches = node.match(scorm2004_regex.CMILangcr);
           if (langMatches) {
             const lang = langMatches[3];
             if (lang !== undefined && lang.length > 0) {
-              if (ValidLanguages[lang.toLowerCase()] === undefined) {
+              if (!ValidLanguages.includes(lang.toLowerCase())) {
                 this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
               }
             }
           }
           seenLang = true;
           break;
-        case 'case_matters':
+        case "case_matters":
           if (!seenLang && !seenOrder && !seenCase) {
-            if (matches[3] !== 'true' && matches[3] !== 'false') {
+            if (matches[3] !== "true" && matches[3] !== "false") {
               this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
             }
           }
 
           seenCase = true;
           break;
-        case 'order_matters':
+        case "order_matters":
           if (!seenCase && !seenLang && !seenOrder) {
-            if (matches[3] !== 'true' && matches[3] !== 'false') {
+            if (matches[3] !== "true" && matches[3] !== "false") {
               this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
             }
           }
@@ -458,7 +531,7 @@ export default class Scorm2004API extends BaseAPI {
         default:
           break;
       }
-      node = node.substr(matches[1].length);
+      node = node.substring(matches[1].length);
       matches = node.match(prefixRegex);
     }
 
@@ -469,7 +542,7 @@ export default class Scorm2004API extends BaseAPI {
    * Replace the whole API with another
    * @param {Scorm2004API} newAPI
    */
-  replaceWithAnotherScormAPI(newAPI) {
+  replaceWithAnotherScormAPI(newAPI: Scorm2004API) {
     // Data Model
     this.cmi = newAPI.cmi;
     this.adl = newAPI.adl;
@@ -481,26 +554,26 @@ export default class Scorm2004API extends BaseAPI {
    * @param {boolean} terminateCommit
    * @return {object|Array}
    */
-  renderCommitCMI(terminateCommit: boolean) {
-    const cmiExport = this.renderCMIToJSONObject();
+  renderCommitCMI(terminateCommit: boolean): object | Array<any> {
+    const cmiExport: RefObject = this.renderCMIToJSONObject();
 
     if (terminateCommit) {
       cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime();
     }
 
     const result = [];
-    const flattened = Utilities.flatten(cmiExport);
+    const flattened: RefObject = Utilities.flatten(cmiExport);
     switch (this.settings.dataCommitFormat) {
-      case 'flattened':
+      case "flattened":
         return Utilities.flatten(cmiExport);
-      case 'params':
+      case "params":
         for (const item in flattened) {
           if ({}.hasOwnProperty.call(flattened, item)) {
             result.push(`${item}=${flattened[item]}`);
           }
         }
         return result;
-      case 'json':
+      case "json":
       default:
         return cmiExport;
     }
@@ -510,28 +583,24 @@ export default class Scorm2004API extends BaseAPI {
    * Attempts to store the data to the LMS
    *
    * @param {boolean} terminateCommit
-   * @return {string}
+   * @return {ResultObject}
    */
-  storeData(terminateCommit: boolean) {
+  storeData(terminateCommit: boolean): ResultObject {
     if (terminateCommit) {
-      if (this.cmi.mode === 'normal') {
-        if (this.cmi.credit === 'credit') {
+      if (this.cmi.mode === "normal") {
+        if (this.cmi.credit === "credit") {
           if (this.cmi.completion_threshold && this.cmi.progress_measure) {
             if (this.cmi.progress_measure >= this.cmi.completion_threshold) {
-              console.debug('Setting Completion Status: Completed');
-              this.cmi.completion_status = 'completed';
+              this.cmi.completion_status = "completed";
             } else {
-              console.debug('Setting Completion Status: Incomplete');
-              this.cmi.completion_status = 'incomplete';
+              this.cmi.completion_status = "incomplete";
             }
           }
           if (this.cmi.scaled_passing_score && this.cmi.score.scaled) {
             if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) {
-              console.debug('Setting Success Status: Passed');
-              this.cmi.success_status = 'passed';
+              this.cmi.success_status = "passed";
             } else {
-              console.debug('Setting Success Status: Failed');
-              this.cmi.success_status = 'failed';
+              this.cmi.success_status = "failed";
             }
           }
         }
@@ -539,34 +608,47 @@ export default class Scorm2004API extends BaseAPI {
     }
 
     let navRequest = false;
-    if (this.adl.nav.request !== (this.startingData?.adl?.nav?.request) &&
-        this.adl.nav.request !== '_none_') {
+    if (
+      this.adl.nav.request !== this.startingData?.adl?.nav?.request &&
+      this.adl.nav.request !== "_none_"
+    ) {
       this.adl.nav.request = encodeURIComponent(this.adl.nav.request);
       navRequest = true;
     }
 
-    const commitObject = this.renderCommitCMI(terminateCommit ||
-        this.settings.alwaysSendTotalTime);
+    const commitObject = this.renderCommitCMI(
+      terminateCommit || this.settings.alwaysSendTotalTime,
+    );
 
     if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {
-      console.debug('Commit (terminated: ' +
-            (terminateCommit ? 'yes' : 'no') + '): ');
+      console.debug(
+        "Commit (terminated: " + (terminateCommit ? "yes" : "no") + "): ",
+      );
       console.debug(commitObject);
     }
-    if (this.settings.lmsCommitUrl) {
-      const result = this.processHttpRequest(this.settings.lmsCommitUrl,
-          commitObject, terminateCommit);
+    if (typeof this.settings.lmsCommitUrl === "string") {
+      const result = this.processHttpRequest(
+        this.settings.lmsCommitUrl,
+        commitObject,
+        terminateCommit,
+      );
 
       // check if this is a sequencing call, and then call the necessary JS
       {
-        if (navRequest && result.navRequest !== undefined &&
-            result.navRequest !== '') {
+        if (
+          navRequest &&
+          result.navRequest !== undefined &&
+          result.navRequest !== ""
+        ) {
           Function(`"use strict";(() => { ${result.navRequest} })()`)();
         }
       }
       return result;
     } else {
-      return global_constants.SCORM_TRUE;
+      return {
+        result: global_constants.SCORM_TRUE,
+        errorCode: 0,
+      };
     }
   }
 }