scorm-again 2.6.2 → 2.6.4

package/src/cmi/scorm2004/comments.ts

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

package/src/cmi/scorm2004/interactions.ts

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

package/src/cmi/scorm2004/learner_preference.ts

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

package/src/cmi/scorm2004/objectives.ts

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

package/src/cmi/scorm2004/score.ts

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

package/src/cmi/scorm2004/validation.ts

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

package/src/constants/regex.ts

@@ -9,7 +9,14 @@ export const scorm12_regex = {
   CMIDecimal: "^-?([0-9]{0,3})(.[0-9]*)?$",
 
   CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$",
-  CMIFeedback: "^.{0,255}$",
+  // Allow storing larger responses for interactions
+  // Some content packages may exceed the 255 character limit
+  // defined in the SCORM 1.2 specification.  The previous
+  // expression truncated these values which resulted in
+  // a "101: General Exception" being thrown when long
+  // answers were supplied.  To support these packages we
+  // relax the limitation and accept any length string.
+  CMIFeedback: "^.*$",
   // This must be redefined
   CMIIndex: "[._](\\d+).",
   // Vocabulary Data Type Definition

package/src/exceptions/aicc_exceptions.ts

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

package/src/exceptions/scorm12_exceptions.ts

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

package/src/exceptions/scorm2004_exceptions.ts

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

package/src/utilities.ts

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

package/test/Scorm12API.spec.ts

@@ -841,6 +841,51 @@ describe("SCORM 1.2 API Tests", () => {
       expect(callback3.calledTwice).toBe(true);
       expect(callback4.calledTwice).toBe(true);
     });
+
+    it("Should handle multiple events in one listener string", async () => {
+      const scorm12API = api({
+        ...DefaultSettings,
+        ...{
+          lmsCommitUrl: "/scorm12",
+          autocommit: true,
+          autocommitSeconds: 1,
+        },
+      });
+      scorm12API.lmsInitialize();
+
+      const callback = sinon.spy();
+      scorm12API.on("LMSSetValue.cmi.core.session_time CommitSuccess", callback);
+
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:01:00");
+      clock.tick(2000);
+
+      await clock.runAllAsync();
+
+      expect(callback.calledTwice).toBe(true);
+    });
+
+    it("Should detach multiple events using off()", async () => {
+      const scorm12API = api({
+        ...DefaultSettings,
+        ...{
+          lmsCommitUrl: "/scorm12",
+          autocommit: true,
+          autocommitSeconds: 1,
+        },
+      });
+      scorm12API.lmsInitialize();
+
+      const callback = sinon.spy();
+      scorm12API.on("LMSSetValue.cmi.core.session_time CommitSuccess", callback);
+      scorm12API.off("LMSSetValue.cmi.core.session_time CommitSuccess", callback);
+
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:01:00");
+      clock.tick(2000);
+
+      await clock.runAllAsync();
+
+      expect(callback.called).toBe(false);
+    });
     it("Should handle CommitError event", async () => {
       const scorm12API = api({
         ...DefaultSettings,

package/test/Scorm2004API.spec.ts

@@ -1356,6 +1356,49 @@ describe("SCORM 2004 API Tests", () => {
       expect(callback3.calledTwice).toBe(true);
       expect(callback4.calledTwice).toBe(true);
     });
+
+    it("Should handle multiple events in one listener string", async () => {
+      const scorm2004API = api({
+        ...DefaultSettings,
+        ...{
+          lmsCommitUrl: "/scorm2004",
+          autocommit: true,
+          autocommitSeconds: 1,
+        },
+      });
+      scorm2004API.lmsInitialize();
+
+      const callback = sinon.spy();
+      scorm2004API.on("SetValue.cmi.learner_id CommitSuccess", callback);
+
+      scorm2004API.lmsSetValue("cmi.learner_id", "@jcputney");
+      scorm2004API.lmsCommit();
+      await clock.runAllAsync();
+
+      expect(callback.calledTwice).toBe(true);
+    });
+
+    it("Should detach multiple events using off()", async () => {
+      const scorm2004API = api({
+        ...DefaultSettings,
+        ...{
+          lmsCommitUrl: "/scorm2004",
+          autocommit: true,
+          autocommitSeconds: 1,
+        },
+      });
+      scorm2004API.lmsInitialize();
+
+      const callback = sinon.spy();
+      scorm2004API.on("SetValue.cmi.learner_id CommitSuccess", callback);
+      scorm2004API.off("SetValue.cmi.learner_id CommitSuccess", callback);
+
+      scorm2004API.lmsSetValue("cmi.learner_id", "@jcputney");
+      scorm2004API.lmsCommit();
+      await clock.runAllAsync();
+
+      expect(callback.called).toBe(false);
+    });
     it("Should handle CommitError event", async () => {
       const scorm2004API = api({
         ...DefaultSettings,

package/tsconfig.json

@@ -3,6 +3,7 @@
     "sourceMap": true,
     "noImplicitAny": true,
     "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
     "declaration": false,
     "module": "es2020",
     "moduleResolution": "Node",