scorm-again 2.6.0 → 2.6.2

package/src/ScormAgain.ts

@@ -1,9 +1,5 @@
-import { AICCImpl } from "./AICC";
-import { Scorm12Impl } from "./Scorm12API";
-import { Scorm2004Impl } from "./Scorm2004API";
-
-const Scorm12API = Scorm12Impl;
-const Scorm2004API = Scorm2004Impl;
-const AICC = AICCImpl;
+import { AICC } from "./AICC";
+import { Scorm12API } from "./Scorm12API";
+import { Scorm2004API } from "./Scorm2004API";
 
 export { Scorm12API, Scorm2004API, AICC };

package/src/constants/default_settings.ts

@@ -1,11 +1,11 @@
-import { LogLevel, ResultObject, Settings } from "../types/api_types";
+import { InternalSettings, LogLevel, ResultObject } from "../types/api_types";
 import { global_constants } from "./api_constants";
 import { LogLevelEnum } from "./enums";
 
 /**
  * Default settings for the SCORM API
  */
-export const DefaultSettings: Settings = {
+export const DefaultSettings: InternalSettings = {
   autocommit: false,
   autocommitSeconds: 10,
   asyncCommit: false,

package/src/types/api_types.ts

@@ -30,6 +30,32 @@ export type Settings = {
   globalObjectiveIds?: string[];
 };
 
+export type InternalSettings = {
+  autocommit: boolean;
+  autocommitSeconds: number;
+  asyncCommit: boolean;
+  sendFullCommit: boolean;
+  lmsCommitUrl: boolean | string;
+  dataCommitFormat: string;
+  commitRequestDataType: string;
+  autoProgress: boolean;
+  logLevel: LogLevel;
+  selfReportSessionTime: boolean;
+  renderCommonCommitFields?: boolean;
+  scoItemIds?: string[];
+  scoItemIdValidator?: false | ((scoItemId: string) => boolean);
+  globalObjectiveIds?: string[];
+  alwaysSendTotalTime: boolean;
+  strict_errors: boolean;
+  xhrHeaders: RefObject;
+  xhrWithCredentials: boolean;
+  mastery_override?: boolean;
+  fetchMode: "cors" | "no-cors" | "same-origin" | "navigate";
+  responseHandler: (response: Response) => Promise<ResultObject>;
+  requestHandler: (commitObject: any) => any;
+  onLogMessage: (messageLevel: LogLevel, logMessage: string) => void;
+};
+
 export type RefObject = {
   [key: string]: any;
 };
@@ -71,5 +97,4 @@ export type LogLevel =
   | "WARN"
   | "ERROR"
   | "NONE"
-  | LogLevelEnum
-  | undefined;
+  | LogLevelEnum;

package/test/AICC.spec.ts

@@ -2,7 +2,7 @@ import { expect } from "expect";
 import { describe, it } from "mocha";
 import * as h from "./api_helpers";
 import { scorm12_errors } from "../src/constants/error_codes";
-import { AICCImpl } from "../src/AICC";
+import { AICC } from "../src/AICC";
 import { DefaultSettings } from "../src/constants/default_settings";
 import * as sinon from "sinon";
 import { CMITries } from "../src/cmi/aicc/tries";
@@ -10,7 +10,7 @@ import { CMIInteractions } from "../src/cmi/scorm12/interactions";
 import { RefObject, Settings } from "../src/types/api_types";
 
 const api = (settings?: Settings, startingData: RefObject = {}) => {
-  const API = new AICCImpl(settings);
+  const API = new AICC(settings);
   API.apiLogLevel = 1;
   if (startingData) {
     API.startingData = startingData;

package/test/Scorm12API.spec.ts

@@ -1,6 +1,6 @@
 import { expect } from "expect";
 import { after, before, describe, it } from "mocha";
-import { Scorm12Impl } from "../src/Scorm12API";
+import { Scorm12API } from "../src/Scorm12API";
 import * as h from "./api_helpers";
 import { scorm12_errors } from "../src/constants/error_codes";
 import { scorm12Values } from "./field_values";
@@ -11,7 +11,7 @@ import { DefaultSettings } from "../src/constants/default_settings";
 
 let clock: sinon.SinonFakeTimers;
 const api = (settings?: Settings, startingData: RefObject = {}) => {
-  const API = new Scorm12Impl(settings);
+  const API = new Scorm12API(settings);
   API.apiLogLevel = 5;
   API.startingData = startingData;
   return API;
@@ -118,6 +118,29 @@ describe("SCORM 1.2 API Tests", () => {
       expect(scorm12API.cmi.objectives.childArray[0].score.max).toEqual("100");
     });
 
+    it("should load nested JSON data into the CMI object in a backwards compatible way with v1", () => {
+      const scorm12API = api();
+      const jsonData = {
+        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 handle empty JSON data", () => {
       const scorm12API = api();
       const jsonData = {};
@@ -515,7 +538,7 @@ describe("SCORM 1.2 API Tests", () => {
       expect(commitObject.totalTimeSeconds).toEqual(
         12 * 3600 + 34 * 60 + 56 + (23 * 3600 + 59 * 60 + 59),
       );
-      expect(commitObject.score.max).toEqual(100);
+      expect(commitObject?.score?.max).toEqual(100);
     });
 
     it("should render commit object with score data", () => {

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 { scorm2004_errors } from "../src/constants/error_codes";
-import { Scorm2004Impl } from "../src/Scorm2004API";
+import { Scorm2004API } from "../src/Scorm2004API";
 import { scorm2004Values } from "./field_values";
 import {
   global_constants,
@@ -17,7 +17,7 @@ import { ADLNav } from "../src/cmi/scorm2004/adl";
 
 let clock: sinon.SinonFakeTimers;
 const api = (settings?: Settings, startingData: RefObject = {}) => {
-  const API = new Scorm2004Impl(settings);
+  const API = new Scorm2004API(settings);
   API.apiLogLevel = 5;
   if (startingData) {
     API.startingData = startingData;
@@ -195,7 +195,7 @@ describe("SCORM 2004 API Tests", () => {
         scorm2004API.setCMIValue("cmi.objectives.1.progress_measure", "0.5");
 
         const globalObjective = scorm2004API.globalObjectives.find(
-          (objective) => objective.id === "Objective 1",
+          (objective: { id: string }) => objective.id === "Objective 1",
         );
 
         expect(scorm2004API.getCMIValue("cmi.objectives.0.id")).toEqual(
@@ -229,7 +229,7 @@ describe("SCORM 2004 API Tests", () => {
         expect(globalObjective?.progress_measure).toEqual("1");
 
         const globalObjective2 = scorm2004API.globalObjectives.find(
-          (objective) => objective.id === "Objective 2",
+          (objective: { id: string }) => objective.id === "Objective 2",
         );
         expect(globalObjective2).toBe(undefined);
       });
@@ -1034,7 +1034,7 @@ describe("SCORM 2004 API Tests", () => {
 
   describe("checkCorrectResponseValue()", () => {
     it("should properly handle the true-false response type for unknown value", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       scorm2004API.checkCorrectResponseValue("true-false", ["unknown"], "true");
       expect(scorm2004API.lmsGetLastError()).toEqual(
         String(scorm2004_errors.TYPE_MISMATCH),
@@ -1042,13 +1042,13 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should properly handle the true-false response type for correct value", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       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 Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       scorm2004API.checkCorrectResponseValue(
         "choice",
         ["x".repeat(4001)],
@@ -1060,25 +1060,25 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should properly handle the choice response type for correct value", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       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 Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       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 Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       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 Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       scorm2004API.checkCorrectResponseValue(
         "matching",
         ["{order_matters=true}0[.]1"],
@@ -1090,28 +1090,28 @@ describe("SCORM 2004 API Tests", () => {
 
   describe("removeCorrectResponsePrefixes()", () => {
     it("should remove the prefix from the string", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       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 Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       const input = "correctResponse";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
       expect(result).toBe("correctResponse");
     });
 
     it("should handle empty strings correctly", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       const input = "";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
       expect(result).toBe("");
     });
 
     it("should handle multiple prefixes correctly", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       const input =
         "{lang=en}{order_matters=true}{case_matters=false}correctResponse";
       const result = scorm2004API.removeCorrectResponsePrefixes(input);
@@ -1119,7 +1119,7 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should throw an error for invalid order_matters value", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       const input = "{order_matters=invalid}correctResponse";
       scorm2004API.removeCorrectResponsePrefixes(input);
       expect(scorm2004API.lmsGetLastError()).toEqual(
@@ -1128,7 +1128,7 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should throw an error for invalid case_matters value", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       const input = "{case_matters=invalid}correctResponse";
       scorm2004API.removeCorrectResponsePrefixes(input);
       expect(scorm2004API.lmsGetLastError()).toEqual(
@@ -1137,14 +1137,14 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should ignore an unknown prefix", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       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 Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       const input = "{lang=xyz}correctResponse";
       scorm2004API.removeCorrectResponsePrefixes(input);
       expect(scorm2004API.lmsGetLastError()).toEqual(
@@ -1174,7 +1174,7 @@ describe("SCORM 2004 API Tests", () => {
     });
 
     it("should call throwSCORMError with the correct arguments in createCorrectResponsesObject", () => {
-      const scorm2004API = new Scorm2004Impl();
+      const scorm2004API = new Scorm2004API();
       const interaction = {
         id: "interaction-id-1",
         type: "invalid-type",

package/tsconfig.json

@@ -4,16 +4,29 @@
     "noImplicitAny": true,
     "noImplicitOverride": true,
     "declaration": false,
-    "module": "es2015",
+    "module": "es2020",
     "moduleResolution": "Node",
     "target": "es5",
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
-    "typeRoots": ["node_modules/@types"],
+    "typeRoots": [
+      "node_modules/@types",
+      "src/types"
+    ],
+    "types": [
+      "node"
+    ],
+    "skipLibCheck": true,
     "removeComments": true,
     "importHelpers": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "exactOptionalPropertyTypes": true,
+    "strictNullChecks": true,
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules"]
-}
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/webpack.config.js

@@ -67,7 +67,7 @@ const cjsConfig = {
   output: {
     path: path.resolve(__dirname, "dist"),
     filename: "[name].js",
-    libraryTarget: "this",
+    libraryTarget: "window",
     environment: {
       arrowFunction: false,
     },