scorm-again 2.4.1 → 2.6.0

package/src/cmi/scorm2004/interactions.ts

@@ -3,11 +3,11 @@
  */
 import { BaseCMI } from "../common/base_cmi";
 import { CMIArray } from "../common/array";
-import ErrorCodes from "../../constants/error_codes";
-import { Scorm2004ValidationError } from "../../exceptions";
-import APIConstants from "../../constants/api_constants";
+import { scorm2004_errors } from "../../constants/error_codes";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
+import { scorm2004_constants } from "../../constants/api_constants";
 import { check2004ValidFormat } from "./validation";
-import Regex from "../../constants/regex";
+import { scorm2004_regex } from "../../constants/regex";
 import { LearnerResponses } from "../../constants/response_constants";
 
 export class CMIInteractions extends CMIArray {
@@ -16,8 +16,8 @@ export class CMIInteractions extends CMIArray {
    */
   constructor() {
     super({
-      children: APIConstants.scorm2004.interactions_children,
-      errorCode: ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      children: scorm2004_constants.interactions_children,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
       errorClass: Scorm2004ValidationError,
     });
   }
@@ -43,14 +43,14 @@ export class CMIInteractionsObject extends BaseCMI {
   constructor() {
     super();
     this.objectives = new CMIArray({
-      errorCode: ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
       errorClass: Scorm2004ValidationError,
-      children: APIConstants.scorm2004.objectives_children,
+      children: scorm2004_constants.objectives_children,
     });
     this.correct_responses = new CMIArray({
-      errorCode: ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
       errorClass: Scorm2004ValidationError,
-      children: APIConstants.scorm2004.correct_responses_children,
+      children: scorm2004_constants.correct_responses_children,
     });
   }
 
@@ -66,6 +66,31 @@ export class CMIInteractionsObject extends BaseCMI {
     this.correct_responses?.initialize();
   }
 
+  /**
+   * Called when the API has been reset
+   */
+  override reset() {
+    this._initialized = false;
+    this._id = "";
+    this._type = "";
+    this._timestamp = "";
+    this._weighting = "";
+    this._learner_response = "";
+    this._result = "";
+    this._latency = "";
+    this._description = "";
+    this.objectives = new CMIArray({
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorClass: Scorm2004ValidationError,
+      children: scorm2004_constants.objectives_children,
+    });
+    this.correct_responses = new CMIArray({
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorClass: Scorm2004ValidationError,
+      children: scorm2004_constants.correct_responses_children,
+    });
+  }
+
   /**
    * Getter for _id
    * @return {string}
@@ -79,7 +104,7 @@ export class CMIInteractionsObject extends BaseCMI {
    * @param {string} id
    */
   set id(id: string) {
-    if (check2004ValidFormat(id, Regex.scorm2004.CMILongIdentifier)) {
+    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {
       this._id = id;
     }
   }
@@ -99,10 +124,10 @@ export class CMIInteractionsObject extends BaseCMI {
   set type(type: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
-      if (check2004ValidFormat(type, Regex.scorm2004.CMIType)) {
+      if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {
         this._type = type;
       }
     }
@@ -123,10 +148,10 @@ export class CMIInteractionsObject extends BaseCMI {
   set timestamp(timestamp: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
-      if (check2004ValidFormat(timestamp, Regex.scorm2004.CMITime)) {
+      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {
         this._timestamp = timestamp;
       }
     }
@@ -147,10 +172,10 @@ export class CMIInteractionsObject extends BaseCMI {
   set weighting(weighting: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
-      if (check2004ValidFormat(weighting, Regex.scorm2004.CMIDecimal)) {
+      if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {
         this._weighting = weighting;
       }
     }
@@ -172,7 +197,7 @@ export class CMIInteractionsObject extends BaseCMI {
   set learner_response(learner_response: string) {
     if (this.initialized && (this._type === "" || this._id === "")) {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
       let nodes = [];
@@ -195,7 +220,7 @@ export class CMIInteractionsObject extends BaseCMI {
               if (values.length === 2) {
                 if (!values[0].match(formatRegex)) {
                   throw new Scorm2004ValidationError(
-                    ErrorCodes.scorm2004.TYPE_MISMATCH,
+                    scorm2004_errors.TYPE_MISMATCH,
                   );
                 } else {
                   if (
@@ -203,26 +228,26 @@ export class CMIInteractionsObject extends BaseCMI {
                     !values[1].match(new RegExp(response_type.format2))
                   ) {
                     throw new Scorm2004ValidationError(
-                      ErrorCodes.scorm2004.TYPE_MISMATCH,
+                      scorm2004_errors.TYPE_MISMATCH,
                     );
                   }
                 }
               } else {
                 throw new Scorm2004ValidationError(
-                  ErrorCodes.scorm2004.TYPE_MISMATCH,
+                  scorm2004_errors.TYPE_MISMATCH,
                 );
               }
             } else {
               if (!nodes[i].match(formatRegex)) {
                 throw new Scorm2004ValidationError(
-                  ErrorCodes.scorm2004.TYPE_MISMATCH,
+                  scorm2004_errors.TYPE_MISMATCH,
                 );
               } else {
                 if (nodes[i] !== "" && response_type.unique) {
                   for (let j = 0; j < i; j++) {
                     if (nodes[i] === nodes[j]) {
                       throw new Scorm2004ValidationError(
-                        ErrorCodes.scorm2004.TYPE_MISMATCH,
+                        scorm2004_errors.TYPE_MISMATCH,
                       );
                     }
                   }
@@ -232,13 +257,13 @@ export class CMIInteractionsObject extends BaseCMI {
           }
         } else {
           throw new Scorm2004ValidationError(
-            ErrorCodes.scorm2004.GENERAL_SET_FAILURE,
+            scorm2004_errors.GENERAL_SET_FAILURE,
           );
         }
 
         this._learner_response = learner_response;
       } else {
-        throw new Scorm2004ValidationError(ErrorCodes.scorm2004.TYPE_MISMATCH);
+        throw new Scorm2004ValidationError(scorm2004_errors.TYPE_MISMATCH);
       }
     }
   }
@@ -256,7 +281,7 @@ export class CMIInteractionsObject extends BaseCMI {
    * @param {string} result
    */
   set result(result: string) {
-    if (check2004ValidFormat(result, Regex.scorm2004.CMIResult)) {
+    if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) {
       this._result = result;
     }
   }
@@ -276,10 +301,10 @@ export class CMIInteractionsObject extends BaseCMI {
   set latency(latency: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
-      if (check2004ValidFormat(latency, Regex.scorm2004.CMITimespan)) {
+      if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {
         this._latency = latency;
       }
     }
@@ -300,13 +325,13 @@ export class CMIInteractionsObject extends BaseCMI {
   set description(description: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
       if (
         check2004ValidFormat(
           description,
-          Regex.scorm2004.CMILangString250,
+          scorm2004_regex.CMILangString250,
           true,
         )
       ) {
@@ -376,6 +401,14 @@ export class CMIInteractionsObjectivesObject extends BaseCMI {
     super();
   }
 
+  /**
+   * Called when the API has been reset
+   */
+  override reset() {
+    this._initialized = false;
+    this._id = "";
+  }
+
   /**
    * Getter for _id
    * @return {string}
@@ -389,7 +422,7 @@ export class CMIInteractionsObjectivesObject extends BaseCMI {
    * @param {string} id
    */
   set id(id: string) {
-    if (check2004ValidFormat(id, Regex.scorm2004.CMILongIdentifier)) {
+    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {
       this._id = id;
     }
   }
@@ -427,6 +460,14 @@ export class CMIInteractionsCorrectResponsesObject extends BaseCMI {
     super();
   }
 
+  /**
+   * Called when the API has been reset
+   */
+  override reset() {
+    this._initialized = false;
+    this._pattern = "";
+  }
+
   /**
    * Getter for _pattern
    * @return {string}
@@ -440,7 +481,7 @@ export class CMIInteractionsCorrectResponsesObject extends BaseCMI {
    * @param {string} pattern
    */
   set pattern(pattern: string) {
-    if (check2004ValidFormat(pattern, Regex.scorm2004.CMIFeedback)) {
+    if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) {
       this._pattern = pattern;
     }
   }

package/src/cmi/scorm2004/learner_preference.ts

@@ -2,14 +2,14 @@
  * Class for SCORM 2004's cmi.learner_preference object
  */
 import { BaseCMI } from "../common/base_cmi";
-import APIConstants from "../../constants/api_constants";
-import { Scorm2004ValidationError } from "../../exceptions";
-import ErrorCodes from "../../constants/error_codes";
+import { scorm2004_constants } from "../../constants/api_constants";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
+import { scorm2004_errors } from "../../constants/error_codes";
 import { check2004ValidFormat, check2004ValidRange } from "./validation";
-import Regex from "../../constants/regex";
+import { scorm2004_regex } from "../../constants/regex";
 
 export class CMILearnerPreference extends BaseCMI {
-  private __children = APIConstants.scorm2004.student_preference_children;
+  private __children = scorm2004_constants.student_preference_children;
   private _audio_level = "1";
   private _language = "";
   private _delivery_speed = "1";
@@ -22,6 +22,13 @@ export class CMILearnerPreference extends BaseCMI {
     super();
   }
 
+  /**
+   * Called when the API has been reset
+   */
+  override reset() {
+    this._initialized = false;
+  }
+
   /**
    * Getter for __children
    * @return {string}
@@ -37,7 +44,7 @@ export class CMILearnerPreference extends BaseCMI {
    * @private
    */
   set _children(_children: string) {
-    throw new Scorm2004ValidationError(ErrorCodes.scorm2004.READ_ONLY_ELEMENT);
+    throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
   }
 
   /**
@@ -54,8 +61,8 @@ export class CMILearnerPreference extends BaseCMI {
    */
   set audio_level(audio_level: string) {
     if (
-      check2004ValidFormat(audio_level, Regex.scorm2004.CMIDecimal) &&
-      check2004ValidRange(audio_level, Regex.scorm2004.audio_range)
+      check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) &&
+      check2004ValidRange(audio_level, scorm2004_regex.audio_range)
     ) {
       this._audio_level = audio_level;
     }
@@ -74,7 +81,7 @@ export class CMILearnerPreference extends BaseCMI {
    * @param {string} language
    */
   set language(language: string) {
-    if (check2004ValidFormat(language, Regex.scorm2004.CMILang)) {
+    if (check2004ValidFormat(language, scorm2004_regex.CMILang)) {
       this._language = language;
     }
   }
@@ -93,8 +100,8 @@ export class CMILearnerPreference extends BaseCMI {
    */
   set delivery_speed(delivery_speed: string) {
     if (
-      check2004ValidFormat(delivery_speed, Regex.scorm2004.CMIDecimal) &&
-      check2004ValidRange(delivery_speed, Regex.scorm2004.speed_range)
+      check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) &&
+      check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)
     ) {
       this._delivery_speed = delivery_speed;
     }
@@ -114,8 +121,8 @@ export class CMILearnerPreference extends BaseCMI {
    */
   set audio_captioning(audio_captioning: string) {
     if (
-      check2004ValidFormat(audio_captioning, Regex.scorm2004.CMISInteger) &&
-      check2004ValidRange(audio_captioning, Regex.scorm2004.text_range)
+      check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) &&
+      check2004ValidRange(audio_captioning, scorm2004_regex.text_range)
     ) {
       this._audio_captioning = audio_captioning;
     }

package/src/cmi/scorm2004/objectives.ts

@@ -1,11 +1,11 @@
 import { CMIArray } from "../common/array";
-import APIConstants from "../../constants/api_constants";
-import ErrorCodes from "../../constants/error_codes";
-import { Scorm2004ValidationError } from "../../exceptions";
+import { scorm2004_errors } from "../../constants/error_codes";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
 import { BaseCMI } from "../common/base_cmi";
 import { Scorm2004CMIScore } from "./score";
 import { check2004ValidFormat, check2004ValidRange } from "./validation";
-import Regex from "../../constants/regex";
+import { scorm2004_regex } from "../../constants/regex";
+import { scorm2004_constants } from "../../constants/api_constants";
 
 /**
  * Class representing SCORM 2004's `cmi.objectives` object
@@ -17,11 +17,32 @@ export class CMIObjectives extends CMIArray {
    */
   constructor() {
     super({
-      children: APIConstants.scorm2004.objectives_children,
-      errorCode: ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      children: scorm2004_constants.objectives_children,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
       errorClass: Scorm2004ValidationError,
     });
   }
+
+  /**
+   * Find an objective by its ID
+   */
+  public findObjectiveById(id: string): CMIObjectivesObject | undefined {
+    return this.childArray.find((objective) => objective.id === id);
+  }
+
+  /**
+   * Find objective by its index
+   */
+  public findObjectiveByIndex(index: number): CMIObjectivesObject {
+    return this.childArray[index];
+  }
+
+  /**
+   * Set an objective at the given index
+   */
+  public setObjectiveByIndex(index: number, objective: CMIObjectivesObject) {
+    this.childArray[index] = objective;
+  }
 }
 
 /**
@@ -42,6 +63,10 @@ export class CMIObjectivesObject extends BaseCMI {
     this.score = new Scorm2004CMIScore();
   }
 
+  override reset() {
+    this._initialized = false;
+  }
+
   public score: Scorm2004CMIScore;
 
   /**
@@ -65,7 +90,7 @@ export class CMIObjectivesObject extends BaseCMI {
    * @param {string} id
    */
   set id(id: string) {
-    if (check2004ValidFormat(id, Regex.scorm2004.CMILongIdentifier)) {
+    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {
       this._id = id;
     }
   }
@@ -85,10 +110,10 @@ export class CMIObjectivesObject extends BaseCMI {
   set success_status(success_status: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
-      if (check2004ValidFormat(success_status, Regex.scorm2004.CMISStatus)) {
+      if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {
         this._success_status = success_status;
       }
     }
@@ -109,10 +134,10 @@ export class CMIObjectivesObject extends BaseCMI {
   set completion_status(completion_status: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
-      if (check2004ValidFormat(completion_status, Regex.scorm2004.CMICStatus)) {
+      if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {
         this._completion_status = completion_status;
       }
     }
@@ -133,12 +158,12 @@ export class CMIObjectivesObject extends BaseCMI {
   set progress_measure(progress_measure: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
       if (
-        check2004ValidFormat(progress_measure, Regex.scorm2004.CMIDecimal) &&
-        check2004ValidRange(progress_measure, Regex.scorm2004.progress_range)
+        check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&
+        check2004ValidRange(progress_measure, scorm2004_regex.progress_range)
       ) {
         this._progress_measure = progress_measure;
       }
@@ -160,13 +185,13 @@ export class CMIObjectivesObject extends BaseCMI {
   set description(description: string) {
     if (this.initialized && this._id === "") {
       throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.DEPENDENCY_NOT_ESTABLISHED,
+        scorm2004_errors.DEPENDENCY_NOT_ESTABLISHED,
       );
     } else {
       if (
         check2004ValidFormat(
           description,
-          Regex.scorm2004.CMILangString250,
+          scorm2004_regex.CMILangString250,
           true,
         )
       ) {

package/src/cmi/scorm2004/score.ts

@@ -2,10 +2,10 @@
  * Class for SCORM 2004's cmi *.score object
  */
 import { CMIScore } from "../common/score";
-import APIConstants from "../../constants/api_constants";
-import ErrorCodes from "../../constants/error_codes";
-import Regex from "../../constants/regex";
-import { Scorm2004ValidationError } from "../../exceptions";
+import { scorm2004_constants } from "../../constants/api_constants";
+import { scorm2004_errors } from "../../constants/error_codes";
+import { scorm2004_regex } from "../../constants/regex";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
 import { check2004ValidFormat, check2004ValidRange } from "./validation";
 
 export class Scorm2004CMIScore extends CMIScore {
@@ -16,16 +16,27 @@ export class Scorm2004CMIScore extends CMIScore {
    */
   constructor() {
     super({
-      score_children: APIConstants.scorm2004.score_children,
+      score_children: scorm2004_constants.score_children,
       max: "",
-      invalidErrorCode: ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      invalidTypeCode: ErrorCodes.scorm2004.TYPE_MISMATCH,
-      invalidRangeCode: ErrorCodes.scorm2004.VALUE_OUT_OF_RANGE,
-      decimalRegex: Regex.scorm2004.CMIDecimal,
+      invalidErrorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      invalidTypeCode: scorm2004_errors.TYPE_MISMATCH,
+      invalidRangeCode: scorm2004_errors.VALUE_OUT_OF_RANGE,
+      decimalRegex: scorm2004_regex.CMIDecimal,
       errorClass: Scorm2004ValidationError,
     });
   }
 
+  /**
+   * Called when the API has been reset
+   */
+  override reset(): void {
+    this._initialized = false;
+    this._scaled = "";
+    this._raw = "";
+    this._min = "";
+    this._max = "";
+  }
+
   /**
    * Getter for _scaled
    * @return {string}
@@ -40,8 +51,8 @@ export class Scorm2004CMIScore extends CMIScore {
    */
   set scaled(scaled: string) {
     if (
-      check2004ValidFormat(scaled, Regex.scorm2004.CMIDecimal) &&
-      check2004ValidRange(scaled, Regex.scorm2004.scaled_range)
+      check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) &&
+      check2004ValidRange(scaled, scorm2004_regex.scaled_range)
     ) {
       this._scaled = scaled;
     }

package/src/cmi/scorm2004/validation.ts

@@ -1,6 +1,6 @@
 import { checkValidFormat, checkValidRange } from "../common/validation";
-import ErrorCodes from "../../constants/error_codes";
-import { Scorm2004ValidationError } from "../../exceptions";
+import { scorm2004_errors } from "../../constants/error_codes";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
 
 /**
  * Helper method, no reason to have to pass the same error codes every time
@@ -17,7 +17,7 @@ export function check2004ValidFormat(
   return checkValidFormat(
     value,
     regexPattern,
-    ErrorCodes.scorm2004.TYPE_MISMATCH,
+    scorm2004_errors.TYPE_MISMATCH,
     Scorm2004ValidationError,
     allowEmptyString,
   );
@@ -36,7 +36,7 @@ export function check2004ValidRange(
   return checkValidRange(
     value,
     rangePattern,
-    ErrorCodes.scorm2004.VALUE_OUT_OF_RANGE,
+    scorm2004_errors.VALUE_OUT_OF_RANGE,
     Scorm2004ValidationError,
   );
 }

package/src/constants/api_constants.ts

@@ -36,6 +36,7 @@ interface Scorm2004Constants {
   student_data_children: string;
   student_preference_children: string;
   interactions_children: string;
+  adl_data_children: string;
   error_descriptions: ErrorDescriptions;
 }
 
@@ -45,34 +46,17 @@ interface GlobalConstants {
   STATE_NOT_INITIALIZED: number;
   STATE_INITIALIZED: number;
   STATE_TERMINATED: number;
-  LOG_LEVEL_DEBUG: number;
-  LOG_LEVEL_INFO: number;
-  LOG_LEVEL_WARNING: number;
-  LOG_LEVEL_ERROR: number;
-  LOG_LEVEL_NONE: number;
 }
 
-interface APIConstants {
-  global: GlobalConstants;
-  scorm12: ScormConstants;
-  aicc: AiccConstants;
-  scorm2004: Scorm2004Constants;
-}
-
-const global: GlobalConstants = {
+export const global_constants: GlobalConstants = {
   SCORM_TRUE: "true",
   SCORM_FALSE: "false",
   STATE_NOT_INITIALIZED: 0,
   STATE_INITIALIZED: 1,
   STATE_TERMINATED: 2,
-  LOG_LEVEL_DEBUG: 1,
-  LOG_LEVEL_INFO: 2,
-  LOG_LEVEL_WARNING: 3,
-  LOG_LEVEL_ERROR: 4,
-  LOG_LEVEL_NONE: 5,
 };
 
-const scorm12: ScormConstants = {
+export const scorm12_constants: ScormConstants = {
   // Children lists
   cmi_children:
     "core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions",
@@ -149,8 +133,8 @@ const scorm12: ScormConstants = {
     },
   },
 };
-const aicc: AiccConstants = {
-  ...scorm12,
+export const aicc_constants: AiccConstants = {
+  ...scorm12_constants,
   ...{
     cmi_children:
       "core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation",
@@ -165,7 +149,8 @@ const aicc: AiccConstants = {
     paths_children: "location_id,date,time,status,why_left,time_in_element",
   },
 };
-const scorm2004: Scorm2004Constants = {
+
+export const scorm2004_constants: Scorm2004Constants = {
   // Children lists
   cmi_children:
     "_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time",
@@ -179,6 +164,7 @@ const scorm2004: Scorm2004Constants = {
     "audio_level,audio_captioning,delivery_speed,language",
   interactions_children:
     "id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description",
+  adl_data_children: "id,store",
   error_descriptions: {
     "0": {
       basicMessage: "No Error",
@@ -309,10 +295,3 @@ const scorm2004: Scorm2004Constants = {
     },
   },
 };
-const APIConstants: APIConstants = {
-  global: global,
-  scorm12: scorm12,
-  aicc: aicc,
-  scorm2004: scorm2004,
-};
-export default APIConstants;