scorm-again 2.5.0 → 2.6.0

package/src/cmi/scorm12/validation.ts

@@ -1,6 +1,6 @@
-import {checkValidFormat, checkValidRange} from "../common/validation";
-import ErrorCodes from "../../constants/error_codes";
-import {Scorm12ValidationError} from "../../exceptions";
+import { checkValidFormat, checkValidRange } from "../common/validation";
+import { scorm12_errors } from "../../constants/error_codes";
+import { Scorm12ValidationError } from "../../exceptions/scorm12_exceptions";
 
 /**
  * Helper method, no reason to have to pass the same error codes every time
@@ -17,7 +17,7 @@ export function check12ValidFormat(
   return checkValidFormat(
     value,
     regexPattern,
-    ErrorCodes.scorm12.TYPE_MISMATCH,
+    scorm12_errors.TYPE_MISMATCH,
     Scorm12ValidationError,
     allowEmptyString,
   );
@@ -36,13 +36,13 @@ export function check12ValidRange(
   allowEmptyString?: boolean,
 ): boolean {
   if (!allowEmptyString && value === "") {
-    throw new Scorm12ValidationError(ErrorCodes.scorm12.VALUE_OUT_OF_RANGE);
+    throw new Scorm12ValidationError(scorm12_errors.VALUE_OUT_OF_RANGE);
   }
 
   return checkValidRange(
     value,
     rangePattern,
-    ErrorCodes.scorm12.VALUE_OUT_OF_RANGE,
+    scorm12_errors.VALUE_OUT_OF_RANGE,
     Scorm12ValidationError,
   );
-}
+}

package/src/cmi/scorm2004/adl.ts

@@ -1,9 +1,11 @@
 import { BaseCMI } from "../common/base_cmi";
-import { Scorm2004ValidationError } from "../../exceptions";
-import ErrorCodes from "../../constants/error_codes";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
 import { check2004ValidFormat } from "./validation";
-import Regex from "../../constants/regex";
+import { scorm2004_regex } from "../../constants/regex";
 import { NAVBoolean } from "../../constants/enums";
+import { CMIArray } from "../common/array";
+import { scorm2004_constants } from "../../constants/api_constants";
+import { scorm2004_errors } from "../../constants/error_codes";
 
 /**
  * Class representing SCORM 2004's adl object
@@ -15,9 +17,11 @@ export class ADL extends BaseCMI {
   constructor() {
     super();
     this.nav = new ADLNav();
+    this.data = new ADLData();
   }
 
   public nav: ADLNav;
+  public data = new ADLData();
 
   /**
    * Called when the API has been initialized after the CMI has been created
@@ -27,20 +31,31 @@ export class ADL extends BaseCMI {
     this.nav?.initialize();
   }
 
+  /**
+   * Called when the API needs to be reset
+   */
+  reset() {
+    this._initialized = false;
+    this.nav?.reset();
+  }
+
   /**
    * toJSON for adl
    * @return {
    *    {
-   *      nav: ADLNav
+   *      nav: ADLNav,
+   *      data: ADLData
    *    }
    *  }
    */
   toJSON(): {
     nav: ADLNav;
+    data: ADLData;
   } {
     this.jsonString = true;
     const result = {
       nav: this.nav,
+      data: this.data,
     };
     delete this.jsonString;
     return result;
@@ -72,6 +87,15 @@ export class ADLNav extends BaseCMI {
     this.request_valid?.initialize();
   }
 
+  /**
+   * Called when the API needs to be reset
+   */
+  reset() {
+    this._initialized = false;
+    this._request = "_none_";
+    this.request_valid?.reset();
+  }
+
   /**
    * Getter for _request
    * @return {string}
@@ -85,7 +109,7 @@ export class ADLNav extends BaseCMI {
    * @param {string} request
    */
   set request(request: string) {
-    if (check2004ValidFormat(request, Regex.scorm2004.NAVEvent)) {
+    if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) {
       this._request = request;
     }
   }
@@ -111,6 +135,97 @@ export class ADLNav extends BaseCMI {
   }
 }
 
+/**
+ * Class representing SCORM 2004's `adl.data` object
+ */
+export class ADLData extends CMIArray {
+  constructor() {
+    super({
+      children: scorm2004_constants.adl_data_children,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
+      errorClass: Scorm2004ValidationError,
+    });
+  }
+}
+
+/**
+ * Class for SCORM 2004's adl.data.n object
+ */
+export class ADLDataObject extends BaseCMI {
+  private _id = "";
+  private _store = "";
+
+  constructor() {
+    super();
+  }
+
+  /**
+   * Called when the API has been reset
+   */
+  reset() {
+    this._initialized = false;
+  }
+
+  /**
+   * Getter for _id
+   * @return {string}
+   */
+  get id(): string {
+    return this._id;
+  }
+
+  /**
+   * Setter for _id
+   * @param {string} id
+   */
+  set id(id: string) {
+    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {
+      this._id = id;
+    }
+  }
+
+  /**
+   * Getter for _store
+   * @return {string}
+   */
+  get store(): string {
+    return this._store;
+  }
+
+  /**
+   * Setter for _store
+   * @param {string} store
+   */
+  set store(store: string) {
+    if (check2004ValidFormat(store, scorm2004_regex.CMILangString4000)) {
+      this._store = store;
+    }
+  }
+
+  /**
+   * toJSON for adl.data.n
+   *
+   * @return {
+   *    {
+   *      id: string,
+   *      store: string
+   *    }
+   *  }
+   */
+  toJSON(): {
+    id: string;
+    store: string;
+  } {
+    this.jsonString = true;
+    const result = {
+      id: this._id,
+      store: this._store,
+    };
+    delete this.jsonString;
+    return result;
+  }
+}
+
 /**
  * Class representing SCORM 2004's adl.nav.request_valid object
  */
@@ -132,6 +247,15 @@ export class ADLNavRequestValid extends BaseCMI {
     super();
   }
 
+  /**
+   * Called when the API has been reset
+   */
+  override reset() {
+    this._initialized = false;
+    this._continue = "unknown";
+    this._previous = "unknown";
+  }
+
   /**
    * Getter for _continue
    * @return {string}
@@ -146,11 +270,9 @@ export class ADLNavRequestValid extends BaseCMI {
    */
   set continue(_continue: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     }
-    if (check2004ValidFormat(_continue, Regex.scorm2004.NAVBoolean)) {
+    if (check2004ValidFormat(_continue, scorm2004_regex.NAVBoolean)) {
       this._continue = _continue;
     }
   }
@@ -169,11 +291,9 @@ export class ADLNavRequestValid extends BaseCMI {
    */
   set previous(_previous: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     }
-    if (check2004ValidFormat(_previous, Regex.scorm2004.NAVBoolean)) {
+    if (check2004ValidFormat(_previous, scorm2004_regex.NAVBoolean)) {
       this._previous = _previous;
     }
   }
@@ -192,18 +312,16 @@ export class ADLNavRequestValid extends BaseCMI {
    */
   set choice(choice: { [key: string]: string }) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     }
     if (typeof choice !== "object") {
-      throw new Scorm2004ValidationError(ErrorCodes.scorm2004.TYPE_MISMATCH);
+      throw new Scorm2004ValidationError(scorm2004_errors.TYPE_MISMATCH);
     }
     for (const key in choice) {
       if ({}.hasOwnProperty.call(choice, key)) {
         if (
-          check2004ValidFormat(choice[key], Regex.scorm2004.NAVBoolean) &&
-          check2004ValidFormat(key, Regex.scorm2004.NAVTarget)
+          check2004ValidFormat(choice[key], scorm2004_regex.NAVBoolean) &&
+          check2004ValidFormat(key, scorm2004_regex.NAVTarget)
         ) {
           this._choice[key] =
             NAVBoolean[choice[key] as keyof typeof NAVBoolean];
@@ -226,18 +344,16 @@ export class ADLNavRequestValid extends BaseCMI {
    */
   set jump(jump: { [key: string]: string }) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     }
     if (typeof jump !== "object") {
-      throw new Scorm2004ValidationError(ErrorCodes.scorm2004.TYPE_MISMATCH);
+      throw new Scorm2004ValidationError(scorm2004_errors.TYPE_MISMATCH);
     }
     for (const key in jump) {
       if ({}.hasOwnProperty.call(jump, key)) {
         if (
-          check2004ValidFormat(jump[key], Regex.scorm2004.NAVBoolean) &&
-          check2004ValidFormat(key, Regex.scorm2004.NAVTarget)
+          check2004ValidFormat(jump[key], scorm2004_regex.NAVBoolean) &&
+          check2004ValidFormat(key, scorm2004_regex.NAVTarget)
         ) {
           this._jump[key] = NAVBoolean[jump[key] as keyof typeof NAVBoolean];
         }

package/src/cmi/scorm2004/cmi.ts

@@ -1,7 +1,7 @@
-import APIConstants from "../../constants/api_constants";
-import Regex from "../../constants/regex";
-import ErrorCodes from "../../constants/error_codes";
-import { Scorm2004ValidationError } from "../../exceptions";
+import { scorm2004_constants } from "../../constants/api_constants";
+import { scorm2004_regex } from "../../constants/regex";
+import { scorm2004_errors } from "../../constants/error_codes";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
 import * as Util from "../../utilities";
 import { BaseRootCMI } from "../common/base_cmi";
 import { check2004ValidFormat, check2004ValidRange } from "./validation";
@@ -38,7 +38,7 @@ export class CMI extends BaseRootCMI {
   public objectives: CMIObjectives;
 
   private __version = "1.0";
-  private __children = APIConstants.scorm2004.cmi_children;
+  private __children = scorm2004_constants.cmi_children;
   private _completion_status = "unknown";
   private _completion_threshold = "";
   private _credit = "credit";
@@ -71,6 +71,27 @@ export class CMI extends BaseRootCMI {
     this.objectives?.initialize();
   }
 
+  /**
+   * Called when API is moving to another SCO
+   */
+  reset() {
+    this._initialized = false;
+
+    this._completion_status = "incomplete";
+    this._exit = "";
+    this._session_time = "PT0H0M0S";
+    this._progress_measure = "";
+    this._location = "";
+
+    this.objectives?.reset(false);
+    this.interactions?.reset(true);
+
+    this.score?.reset();
+    this.comments_from_learner?.reset();
+    this.comments_from_lms?.reset();
+    this.learner_preference?.reset();
+  }
+
   /**
    * Getter for __version
    * @return {string}
@@ -86,7 +107,7 @@ export class CMI extends BaseRootCMI {
    * @private
    */
   set _version(_version: string) {
-    throw new Scorm2004ValidationError(ErrorCodes.scorm2004.READ_ONLY_ELEMENT);
+    throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
   }
 
   /**
@@ -104,7 +125,7 @@ export class CMI extends BaseRootCMI {
    * @private
    */
   set _children(_children: number) {
-    throw new Scorm2004ValidationError(ErrorCodes.scorm2004.READ_ONLY_ELEMENT);
+    throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
   }
 
   /**
@@ -120,7 +141,7 @@ export class CMI extends BaseRootCMI {
    * @param {string} completion_status
    */
   set completion_status(completion_status: string) {
-    if (check2004ValidFormat(completion_status, Regex.scorm2004.CMICStatus)) {
+    if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {
       this._completion_status = completion_status;
     }
   }
@@ -139,9 +160,7 @@ export class CMI extends BaseRootCMI {
    */
   set completion_threshold(completion_threshold: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._completion_threshold = completion_threshold;
     }
@@ -161,9 +180,7 @@ export class CMI extends BaseRootCMI {
    */
   set credit(credit: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._credit = credit;
     }
@@ -183,9 +200,7 @@ export class CMI extends BaseRootCMI {
    */
   set entry(entry: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._entry = entry;
     }
@@ -197,9 +212,7 @@ export class CMI extends BaseRootCMI {
    */
   get exit(): string {
     if (!this.jsonString) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.WRITE_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.WRITE_ONLY_ELEMENT);
     }
     return this._exit;
   }
@@ -209,7 +222,7 @@ export class CMI extends BaseRootCMI {
    * @param {string} exit
    */
   set exit(exit: string) {
-    if (check2004ValidFormat(exit, Regex.scorm2004.CMIExit, true)) {
+    if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) {
       this._exit = exit;
     }
   }
@@ -228,9 +241,7 @@ export class CMI extends BaseRootCMI {
    */
   set launch_data(launch_data: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._launch_data = launch_data;
     }
@@ -250,9 +261,7 @@ export class CMI extends BaseRootCMI {
    */
   set learner_id(learner_id: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._learner_id = learner_id;
     }
@@ -272,9 +281,7 @@ export class CMI extends BaseRootCMI {
    */
   set learner_name(learner_name: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._learner_name = learner_name;
     }
@@ -293,7 +300,7 @@ export class CMI extends BaseRootCMI {
    * @param {string} location
    */
   set location(location: string) {
-    if (check2004ValidFormat(location, Regex.scorm2004.CMIString1000)) {
+    if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) {
       this._location = location;
     }
   }
@@ -312,9 +319,7 @@ export class CMI extends BaseRootCMI {
    */
   set max_time_allowed(max_time_allowed: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._max_time_allowed = max_time_allowed;
     }
@@ -334,9 +339,7 @@ export class CMI extends BaseRootCMI {
    */
   set mode(mode: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._mode = mode;
     }
@@ -356,8 +359,8 @@ export class CMI extends BaseRootCMI {
    */
   set progress_measure(progress_measure: string) {
     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;
     }
@@ -377,9 +380,7 @@ export class CMI extends BaseRootCMI {
    */
   set scaled_passing_score(scaled_passing_score: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._scaled_passing_score = scaled_passing_score;
     }
@@ -391,9 +392,7 @@ export class CMI extends BaseRootCMI {
    */
   get session_time(): string {
     if (!this.jsonString) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.WRITE_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.WRITE_ONLY_ELEMENT);
     }
     return this._session_time;
   }
@@ -403,7 +402,7 @@ export class CMI extends BaseRootCMI {
    * @param {string} session_time
    */
   set session_time(session_time: string) {
-    if (check2004ValidFormat(session_time, Regex.scorm2004.CMITimespan)) {
+    if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) {
       this._session_time = session_time;
     }
   }
@@ -421,7 +420,7 @@ export class CMI extends BaseRootCMI {
    * @param {string} success_status
    */
   set success_status(success_status: string) {
-    if (check2004ValidFormat(success_status, Regex.scorm2004.CMISStatus)) {
+    if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {
       this._success_status = success_status;
     }
   }
@@ -440,7 +439,7 @@ export class CMI extends BaseRootCMI {
    */
   set suspend_data(suspend_data: string) {
     if (
-      check2004ValidFormat(suspend_data, Regex.scorm2004.CMIString64000, true)
+      check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000, true)
     ) {
       this._suspend_data = suspend_data;
     }
@@ -460,9 +459,7 @@ export class CMI extends BaseRootCMI {
    */
   set time_limit_action(time_limit_action: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._time_limit_action = time_limit_action;
     }
@@ -482,9 +479,7 @@ export class CMI extends BaseRootCMI {
    */
   set total_time(total_time: string) {
     if (this.initialized) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       this._total_time = total_time;
     }
@@ -507,7 +502,7 @@ export class CMI extends BaseRootCMI {
     return Util.addTwoDurations(
       this._total_time,
       sessionTime,
-      Regex.scorm2004.CMITimespan,
+      scorm2004_regex.CMITimespan,
     );
   }
 

package/src/cmi/scorm2004/comments.ts

@@ -1,10 +1,10 @@
 import { CMIArray } from "../common/array";
-import APIConstants from "../../constants/api_constants";
-import ErrorCodes from "../../constants/error_codes";
-import { Scorm2004ValidationError } from "../../exceptions";
+import { scorm2004_constants } from "../../constants/api_constants";
+import { scorm2004_errors } from "../../constants/error_codes";
+import { Scorm2004ValidationError } from "../../exceptions/scorm2004_exceptions";
 import { BaseCMI } from "../common/base_cmi";
 import { check2004ValidFormat } from "./validation";
-import Regex from "../../constants/regex";
+import { scorm2004_regex } from "../../constants/regex";
 
 /**
  * Class representing SCORM 2004's cmi.comments_from_lms object
@@ -16,8 +16,8 @@ export class CMICommentsFromLMS extends CMIArray {
    */
   constructor() {
     super({
-      children: APIConstants.scorm2004.comments_children,
-      errorCode: ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      children: scorm2004_constants.comments_children,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
       errorClass: Scorm2004ValidationError,
     });
   }
@@ -33,8 +33,8 @@ export class CMICommentsFromLearner extends CMIArray {
    */
   constructor() {
     super({
-      children: APIConstants.scorm2004.comments_children,
-      errorCode: ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      children: scorm2004_constants.comments_children,
+      errorCode: scorm2004_errors.READ_ONLY_ELEMENT,
       errorClass: Scorm2004ValidationError,
     });
   }
@@ -62,6 +62,13 @@ export class CMICommentsObject extends BaseCMI {
     this._readOnlyAfterInit = readOnlyAfterInit;
   }
 
+  /**
+   * Called when the API has been reset
+   */
+  reset(): void {
+    this._initialized = false;
+  }
+
   /**
    * Getter for _comment
    * @return {string}
@@ -76,12 +83,10 @@ export class CMICommentsObject extends BaseCMI {
    */
   set comment(comment: string) {
     if (this.initialized && this._readOnlyAfterInit) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
       if (
-        check2004ValidFormat(comment, Regex.scorm2004.CMILangString4000, true)
+        check2004ValidFormat(comment, scorm2004_regex.CMILangString4000, true)
       ) {
         this._comment = comment;
       }
@@ -102,11 +107,9 @@ export class CMICommentsObject extends BaseCMI {
    */
   set location(location: string) {
     if (this.initialized && this._readOnlyAfterInit) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
-      if (check2004ValidFormat(location, Regex.scorm2004.CMIString250)) {
+      if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {
         this._location = location;
       }
     }
@@ -126,11 +129,9 @@ export class CMICommentsObject extends BaseCMI {
    */
   set timestamp(timestamp: string) {
     if (this.initialized && this._readOnlyAfterInit) {
-      throw new Scorm2004ValidationError(
-        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
-      );
+      throw new Scorm2004ValidationError(scorm2004_errors.READ_ONLY_ELEMENT);
     } else {
-      if (check2004ValidFormat(timestamp, Regex.scorm2004.CMITime)) {
+      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {
         this._timestamp = timestamp;
       }
     }