scorm-again 2.3.0 → 2.4.1

package/src/cmi/scorm2004/adl.ts

@@ -22,7 +22,7 @@ export class ADL extends BaseCMI {
   /**
    * Called when the API has been initialized after the CMI has been created
    */
-  initialize() {
+  override initialize() {
     super.initialize();
     this.nav?.initialize();
   }
@@ -67,7 +67,7 @@ export class ADLNav extends BaseCMI {
   /**
    * Called when the API has been initialized after the CMI has been created
    */
-  initialize() {
+  override initialize() {
     super.initialize();
     this.request_valid?.initialize();
   }

package/src/cmi/scorm2004/cmi.ts

@@ -61,7 +61,7 @@ export class CMI extends BaseRootCMI {
   /**
    * Called when the API has been initialized after the CMI has been created
    */
-  initialize() {
+  override initialize() {
     super.initialize();
     this.learner_preference?.initialize();
     this.score?.initialize();

package/src/cmi/scorm2004/interactions.ts

@@ -60,7 +60,7 @@ export class CMIInteractionsObject extends BaseCMI {
   /**
    * Called when the API has been initialized after the CMI has been created
    */
-  initialize() {
+  override initialize() {
     super.initialize();
     this.objectives?.initialize();
     this.correct_responses?.initialize();

package/src/cmi/scorm2004/objectives.ts

@@ -47,7 +47,7 @@ export class CMIObjectivesObject extends BaseCMI {
   /**
    * Called when the API has been initialized after the CMI has been created
    */
-  initialize() {
+  override initialize() {
     super.initialize();
     this.score?.initialize();
   }

package/src/cmi/scorm2004/score.ts

@@ -59,7 +59,7 @@ export class Scorm2004CMIScore extends CMIScore {
    *    }
    *  }
    */
-  toJSON(): {
+  override toJSON(): {
     scaled: string;
     raw: string;
     min: string;

package/src/constants/default_settings.ts

@@ -20,9 +20,14 @@ export const DefaultSettings: Settings = {
   strict_errors: true,
   xhrHeaders: {},
   xhrWithCredentials: false,
+  fetchMode: "cors",
   responseHandler: async function (response: Response): Promise<ResultObject> {
     if (typeof response !== "undefined") {
-      const httpResult = JSON.parse(await response.text());
+      const responseText = await response.text();
+      let httpResult = null;
+      if (responseText) {
+        httpResult = JSON.parse(responseText);
+      }
       if (
         httpResult === null ||
         !{}.hasOwnProperty.call(httpResult, "result")

package/src/types/api_types.ts

@@ -15,6 +15,7 @@ export type Settings = {
   strict_errors?: boolean;
   xhrHeaders?: RefObject;
   xhrWithCredentials?: boolean;
+  fetchMode?: "cors" | "no-cors" | "same-origin" | "navigate";
   responseHandler?: (response: Response) => Promise<ResultObject>;
   requestHandler?: (commitObject: any) => any;
   onLogMessage?: (messageLevel: number, logMessage: string) => void;

package/test/AICC.spec.ts

@@ -2,12 +2,12 @@ import { expect } from "expect";
 import { describe } from "mocha";
 import * as h from "./api_helpers";
 import ErrorCodes from "../src/constants/error_codes";
-import AICC from "../src/AICC";
+import { AICCImpl } from "../src/AICC";
 
 const scorm12_error_codes = ErrorCodes.scorm12;
 
 const api = () => {
-  const API = new AICC();
+  const API = new AICCImpl();
   API.apiLogLevel = 1;
   return API;
 };

package/test/Scorm12API.spec.ts

@@ -1,6 +1,6 @@
 import { expect } from "expect";
 import { after, before, describe, it } from "mocha";
-import Scorm12API from "../src/Scorm12API";
+import { Scorm12Impl } from "../src/Scorm12API";
 import * as h from "./api_helpers";
 import ErrorCodes from "../src/constants/error_codes";
 import { scorm12Values } from "./field_values";
@@ -13,14 +13,14 @@ const scorm12_error_codes = ErrorCodes.scorm12;
 
 let clock: sinon.SinonFakeTimers;
 const api = (settings?: Settings, startingData: RefObject = {}) => {
-  const API = new Scorm12API(settings);
+  const API = new Scorm12Impl(settings);
   API.apiLogLevel = 5;
   API.startingData = startingData;
   return API;
 };
 const apiInitialized = (settings?: Settings, startingData: RefObject = {}) => {
   const API = api(settings);
-  API.loadFromJSON(startingData ? startingData : {}, "");
+  API.loadFromJSON(startingData ? startingData : {});
   API.lmsInitialize();
   return API;
 };
@@ -51,6 +51,106 @@ describe("SCORM 1.2 API Tests", () => {
     clock.restore();
   });
 
+  describe("loadFromJSON()", () => {
+    it("should load JSON data into the CMI object", () => {
+      const scorm12API = api();
+      const jsonData = {
+        cmi: {
+          core: {
+            student_id: "student_1",
+            student_name: "John Doe",
+            lesson_status: "incomplete",
+          },
+        },
+      };
+
+      scorm12API.loadFromJSON(jsonData);
+      scorm12API.lmsInitialize();
+
+      expect(scorm12API.cmi.core.student_id).toEqual("student_1");
+      expect(scorm12API.cmi.core.student_name).toEqual("John Doe");
+      expect(scorm12API.cmi.core.lesson_status).toEqual("incomplete");
+    });
+
+    it("should load nested JSON data into the CMI object", () => {
+      const scorm12API = api();
+      const jsonData = {
+        cmi: {
+          objectives: {
+            "0": {
+              id: "obj_1",
+              score: {
+                raw: "85",
+                min: "0",
+                max: "100",
+              },
+            },
+          },
+        },
+      };
+
+      scorm12API.loadFromJSON(jsonData);
+
+      expect(scorm12API.cmi.objectives.childArray[0].id).toEqual("obj_1");
+      expect(scorm12API.cmi.objectives.childArray[0].score.raw).toEqual("85");
+      expect(scorm12API.cmi.objectives.childArray[0].score.min).toEqual("0");
+      expect(scorm12API.cmi.objectives.childArray[0].score.max).toEqual("100");
+    });
+
+    it("should load nested cmi JSON data into the CMI object", () => {
+      const scorm12API = api();
+      const jsonData = {
+        objectives: {
+          "0": {
+            id: "obj_1",
+            score: {
+              raw: "85",
+              min: "0",
+              max: "100",
+            },
+          },
+        },
+      };
+
+      scorm12API.loadFromJSON(jsonData, "cmi");
+
+      expect(scorm12API.cmi.objectives.childArray[0].id).toEqual("obj_1");
+      expect(scorm12API.cmi.objectives.childArray[0].score.raw).toEqual("85");
+      expect(scorm12API.cmi.objectives.childArray[0].score.min).toEqual("0");
+      expect(scorm12API.cmi.objectives.childArray[0].score.max).toEqual("100");
+    });
+
+    it("should handle empty JSON data", () => {
+      const scorm12API = api();
+      const jsonData = {};
+
+      scorm12API.loadFromJSON(jsonData);
+
+      expect(scorm12API.cmi.core.student_id).toBeFalsy();
+      expect(scorm12API.cmi.core.student_name).toBeFalsy();
+      expect(scorm12API.cmi.core.lesson_status).toBe("not attempted");
+    });
+
+    it("should not load data if API is initialized", () => {
+      const scorm12API = apiInitialized();
+      const jsonData = {
+        cmi: {
+          core: {
+            student_id: "student_1",
+            student_name: "John Doe",
+            lesson_status: "incomplete",
+          },
+        },
+      };
+
+      scorm12API.loadFromJSON(jsonData);
+
+      expect(scorm12API.cmi.core.student_id).toBeFalsy();
+      expect(scorm12API.cmi.core.student_name).toBeFalsy();
+      expect(scorm12API.cmi.core.lesson_status).toBe("not attempted");
+    });
+  });
+
   describe("LMSSetValue()", () => {
     h.checkValidValues({
       api: apiInitialized(),
@@ -537,6 +637,77 @@ describe("SCORM 1.2 API Tests", () => {
     });
   });
 
+  describe("LMSCommit Debounce Tests", () => {
+    it("should debounce LMSCommit calls when autocommit is true", async () => {
+      const scorm12API = api({
+        ...DefaultSettings,
+        autocommit: true,
+        autocommitSeconds: 1,
+      });
+      scorm12API.lmsInitialize();
+
+      const commitSpy = sinon.spy(scorm12API, "commit");
+
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:01:00");
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:02:00");
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:03:00");
+
+      clock.tick(2000);
+      await clock.runAllAsync();
+
+      expect(commitSpy.calledOnce).toBe(true);
+    });
+
+    it("should call LMSCommit only once within the debounce period ", async () => {
+      const scorm12API = api({
+        ...DefaultSettings,
+        asyncCommit: true,
+        autocommit: true,
+      });
+      scorm12API.lmsInitialize();
+
+      const commitSpy = sinon.spy(scorm12API, "commit");
+
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:01:00");
+
+      scorm12API.lmsCommit();
+      clock.tick(100);
+
+      scorm12API.lmsCommit();
+      clock.tick(100);
+
+      scorm12API.lmsCommit();
+      clock.tick(100);
+
+      clock.tick(1000);
+      await clock.runAllAsync();
+
+      expect(commitSpy.calledOnce).toBe(true);
+    });
+
+    it("should call LMSCommit multiple times if debounce period is exceeded", async () => {
+      const scorm12API = api({
+        ...DefaultSettings,
+        autocommit: true,
+        autocommitSeconds: 1,
+      });
+      scorm12API.lmsInitialize();
+
+      const commitSpy = sinon.spy(scorm12API, "commit");
+
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:01:00");
+      clock.tick(2000);
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:02:00");
+      clock.tick(2000);
+      scorm12API.lmsSetValue("cmi.core.session_time", "00:03:00");
+
+      clock.tick(2000);
+      await clock.runAllAsync();
+
+      expect(commitSpy.calledThrice).toBe(true);
+    });
+  });
+
   describe("Event Handlers", () => {
     it("Should handle SetValue.cmi.core.student_name event", () => {
       const scorm12API = apiInitialized();

package/test/Scorm2004API.spec.ts

@@ -4,7 +4,7 @@ import * as sinon from "sinon";
 import * as h from "./api_helpers";
 import Pretender from "fetch-pretender";
 import ErrorCodes from "../src/constants/error_codes";
-import Scorm2004API from "../src/Scorm2004API";
+import { Scorm2004Impl } from "../src/Scorm2004API";
 import { scorm2004Values } from "./field_values";
 import APIConstants from "../src/constants/api_constants";
 import { RefObject, Settings } from "../src/types/api_types";
@@ -15,7 +15,7 @@ const scorm2004_error_codes = ErrorCodes.scorm2004;
 
 let clock: sinon.SinonFakeTimers;
 const api = (settings?: Settings, startingData: RefObject = {}) => {
-  const API = new Scorm2004API(settings);
+  const API = new Scorm2004Impl(settings);
   API.apiLogLevel = 5;
   if (startingData) {
     API.startingData = startingData;
@@ -949,7 +949,7 @@ describe("SCORM 2004 API Tests", () => {
 
   describe("checkCorrectResponseValue()", () => {
     it("should properly handle the true-false response type for unknown value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       scorm2004API.checkCorrectResponseValue("true-false", ["unknown"], "true");
       expect(scorm2004API.lmsGetLastError()).toEqual(
         String(scorm2004_error_codes.TYPE_MISMATCH),
@@ -957,13 +957,13 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should properly handle the true-false response type for correct value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       scorm2004API.checkCorrectResponseValue("true-false", ["true"], "true");
       expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
     });
 
     it("should properly handle the choice response type for value over 4000 characters", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       scorm2004API.checkCorrectResponseValue(
         "choice",
         ["x".repeat(4001)],
@@ -975,25 +975,25 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should properly handle the choice response type for correct value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       scorm2004API.checkCorrectResponseValue("choice", ["true"], "true");
       expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
     });
 
     it("should properly handle the fill-in response type for correct value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       scorm2004API.checkCorrectResponseValue("fill-in", ["true"], "true");
       expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
     });
 
     it("should properly handle the long-fill-in response type for correct value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       scorm2004API.checkCorrectResponseValue("long-fill-in", ["true"], "true");
       expect(scorm2004API.lmsGetLastError()).toEqual(String(0));
     });
 
     it("should properly handle the matching response type for correct value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       scorm2004API.checkCorrectResponseValue(
         "matching",
         ["{order_matters=true}0[.]1"],
@@ -1005,28 +1005,28 @@ describe("SCORM 2004 API Tests", () => {
 
   describe("removeCorrectResponsePrefixes()", () => {
     it("should remove the prefix from the string", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input = "{order_matters=true}correctResponse";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
       expect(result).toBe("correctResponse");
     });
 
     it("should return the original string if no prefix is present", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input = "correctResponse";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
       expect(result).toBe("correctResponse");
     });
 
     it("should handle empty strings correctly", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input = "";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
       expect(result).toBe("");
     });
 
     it("should handle multiple prefixes correctly", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input =
         "{lang=en}{order_matters=true}{case_matters=false}correctResponse";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
@@ -1034,7 +1034,7 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should throw an error for invalid order_matters value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input = "{order_matters=invalid}correctResponse";
       scorm2004API.removeCorrectResponsePrefixes(input);
       expect(scorm2004API.lmsGetLastError()).toEqual(
@@ -1043,7 +1043,7 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should throw an error for invalid case_matters value", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input = "{case_matters=invalid}correctResponse";
       scorm2004API.removeCorrectResponsePrefixes(input);
       expect(scorm2004API.lmsGetLastError()).toEqual(
@@ -1052,14 +1052,14 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should ignore an unknown prefix", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input = "{unknown=true}correctResponse";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
       expect(result).toBe("{unknown=true}correctResponse");
     });
 
     it("should throw an error with an invalid language code", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const input = "{lang=xyz}correctResponse";
       scorm2004API.removeCorrectResponsePrefixes(input);
       expect(scorm2004API.lmsGetLastError()).toEqual(
@@ -1089,7 +1089,7 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should call throwSCORMError with the correct arguments in createCorrectResponsesObject", () => {
-      const scorm2004API = new Scorm2004API();
+      const scorm2004API = new Scorm2004Impl();
       const interaction = {
         id: "interaction-id-1",
         type: "invalid-type",

package/tsconfig.json

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "sourceMap": true,
     "noImplicitAny": true,
+    "noImplicitOverride": true,
     "declaration": false,
     "module": "es2015",
     "moduleResolution": "Node",

package/webpack.config.js

@@ -14,29 +14,23 @@ const TSLoader = {
   },
 };
 
-export default {
+const commonConfig = {
   mode: "production",
   devtool: "source-map",
   entry: {
-    aicc: "./src/exports/aicc.js",
-    scorm12: "./src/exports/scorm12.js",
-    scorm2004: "./src/exports/scorm2004.js",
-    "scorm-again": "./src/exports/scorm-again.js",
-    "aicc.min": "./src/exports/aicc.js",
-    "scorm12.min": "./src/exports/scorm12.js",
-    "scorm2004.min": "./src/exports/scorm2004.js",
-    "scorm-again.min": "./src/exports/scorm-again.js",
+    aicc: "./src/AICC.ts",
+    scorm12: "./src/Scorm12API.ts",
+    scorm2004: "./src/Scorm2004API.ts",
+    "scorm-again": "./src/ScormAgain.ts",
+    "aicc.min": "./src/AICC.ts",
+    "scorm12.min": "./src/Scorm12API.ts",
+    "scorm2004.min": "./src/Scorm2004API.ts",
+    "scorm-again.min": "./src/ScormAgain.ts",
   },
   target: ["web", "es5"],
   module: {
     rules: [TSLoader],
   },
-  output: {
-    path: path.resolve(__dirname, "dist"),
-    environment: {
-      arrowFunction: false,
-    },
-  },
   optimization: {
     minimize: true,
     minimizer: [
@@ -63,3 +57,32 @@ export default {
     }),
   ],
 };
+
+const cjsConfig = {
+  ...commonConfig,
+  output: {
+    path: path.resolve(__dirname, "dist"),
+    filename: "[name].js",
+    libraryTarget: "this",
+    environment: {
+      arrowFunction: false,
+    },
+  },
+};
+
+const esmConfig = {
+  ...commonConfig,
+  experiments: {
+    outputModule: true,
+  },
+  output: {
+    path: path.resolve(__dirname, "dist/esm"),
+    filename: "[name].js",
+    libraryTarget: "module",
+    environment: {
+      arrowFunction: false,
+    },
+  },
+};
+
+export default [cjsConfig, esmConfig];

package/src/exports/aicc.js

@@ -1,3 +0,0 @@
-import AICC from "../AICC.ts";
-
-window.AICC = AICC;

package/src/exports/scorm-again.js

@@ -1,7 +0,0 @@
-import Scorm2004API from "../Scorm2004API.ts";
-import Scorm12API from "../Scorm12API.ts";
-import AICC from "../AICC.ts";
-
-window.Scorm12API = Scorm12API;
-window.Scorm2004API = Scorm2004API;
-window.AICC = AICC;

package/src/exports/scorm12.js

@@ -1,3 +0,0 @@
-import Scorm12API from "../Scorm12API.ts";
-
-window.Scorm12API = Scorm12API;

package/src/exports/scorm2004.js

@@ -1,3 +0,0 @@
-import Scorm2004API from "../Scorm2004API.ts";
-
-window.Scorm2004API = Scorm2004API;

package/src/utilities/debounce.ts

@@ -1,31 +0,0 @@
-/**
- * Debounce function to delay the execution of a given function.
- *
- * @param func - The function to debounce.
- * @param wait - The number of milliseconds to delay.
- * @param immediate - If `true`, the function will be triggered on the leading edge instead of the trailing.
- * @returns A debounced version of the provided function.
- */
-export function debounce<T extends (...args: any[]) => void>(
-  func: T,
-  wait: number,
-  immediate = false,
-): (...args: Parameters<T>) => void {
-  let timeout: ReturnType<typeof setTimeout> | null;
-
-  return function (this: any, ...args: Parameters<T>) {
-    const context = this;
-
-    const later = () => {
-      timeout = null;
-      if (!immediate) func.apply(context, args);
-    };
-
-    const callNow = immediate && !timeout;
-
-    if (timeout) clearTimeout(timeout);
-    timeout = setTimeout(later, wait);
-
-    if (callNow) func.apply(context, args);
-  };
-}

package/test/utilities/debounce.spec.ts

@@ -1,56 +0,0 @@
-import { expect } from "expect";
-import * as sinon from "sinon";
-import { debounce } from "../../src/utilities/debounce";
-
-describe("debounce", () => {
-  it("executes the function after the specified wait time", (done) => {
-    const mockFunction = sinon.spy();
-    const debouncedFunction = debounce(mockFunction, 100);
-
-    debouncedFunction();
-    expect(mockFunction.called).toBe(false);
-
-    setTimeout(() => {
-      expect(mockFunction.called).toBe(true);
-      done();
-    }, 150);
-  });
-
-  it("executes the function immediately if immediate is true", () => {
-    const mockFunction = sinon.spy();
-    const debouncedFunction = debounce(mockFunction, 100, true);
-
-    debouncedFunction();
-    expect(mockFunction.called).toBe(true);
-  });
-
-  it("does not execute the function if called again within the wait time", (done) => {
-    const mockFunction = sinon.spy();
-    const debouncedFunction = debounce(mockFunction, 100);
-
-    debouncedFunction();
-    debouncedFunction();
-
-    setTimeout(() => {
-      expect(mockFunction.calledOnce).toBe(true);
-      done();
-    }, 150);
-  });
-
-  it("executes the function again after the wait time if called again", (done) => {
-    const mockFunction = sinon.spy();
-    const debouncedFunction = debounce(mockFunction, 100);
-
-    debouncedFunction();
-
-    setTimeout(() => {
-      debouncedFunction();
-      expect(mockFunction.calledOnce).toBe(true);
-
-      setTimeout(() => {
-        expect(mockFunction.calledTwice).toBe(true);
-        done();
-      }, 150);
-    }, 150);
-  });
-});