scorm-again 2.6.1 → 2.6.2

package/dist/types/constants/response_constants.d.ts

@@ -0,0 +1,16 @@
+export declare const LearnerResponses: Responses;
+export declare const CorrectResponses: Responses;
+export type ResponseType = {
+    format: string;
+    max: number;
+    delimiter: string;
+    unique: boolean;
+    duplicate?: boolean;
+    format2?: string;
+    delimiter2?: string;
+    limit?: number;
+    delimiter3?: string;
+};
+export type Responses = {
+    [key: string]: ResponseType;
+};

package/dist/types/exceptions/aicc_exceptions.d.ts

@@ -0,0 +1,4 @@
+import { ValidationError } from "../exceptions";
+export declare class AICCValidationError extends ValidationError {
+    constructor(errorCode: number);
+}

package/dist/types/exceptions/scorm12_exceptions.d.ts

@@ -0,0 +1,4 @@
+import { ValidationError } from "../exceptions";
+export declare class Scorm12ValidationError extends ValidationError {
+    constructor(errorCode: number);
+}

package/dist/types/exceptions/scorm2004_exceptions.d.ts

@@ -0,0 +1,4 @@
+import { ValidationError } from "../exceptions";
+export declare class Scorm2004ValidationError extends ValidationError {
+    constructor(errorCode: number);
+}

package/dist/types/exceptions.d.ts

@@ -0,0 +1,18 @@
+type APIError = {
+    errorCode: number;
+    errorMessage: string;
+    detailedMessage: string;
+};
+export declare class BaseScormValidationError extends Error {
+    constructor(errorCode: number);
+    private readonly _errorCode;
+    get errorCode(): number;
+}
+export declare class ValidationError extends BaseScormValidationError implements APIError {
+    constructor(errorCode: number, errorMessage: string, detailedMessage?: string);
+    private readonly _errorMessage;
+    private readonly _detailedMessage;
+    get errorMessage(): string;
+    get detailedMessage(): string;
+}
+export {};

package/dist/types/helpers/scheduled_commit.d.ts

@@ -0,0 +1,10 @@
+import BaseAPI from "../BaseAPI";
+export declare class ScheduledCommit {
+    private _API;
+    private _cancelled;
+    private readonly _timeout;
+    private readonly _callback;
+    constructor(API: BaseAPI, when: number, callback: string);
+    cancel(): void;
+    wrapper(): void;
+}

package/dist/types/interfaces/IBaseAPI.d.ts

@@ -0,0 +1,22 @@
+import { RefObject, ResultObject } from "../types/api_types";
+import { BaseCMI } from "../cmi/common/base_cmi";
+export interface IBaseAPI {
+    cmi: BaseCMI;
+    startingData?: RefObject;
+    initialize(callbackName: string, initializeMessage?: string, terminationMessage?: string): string;
+    lmsInitialize(): string;
+    lmsFinish(): string;
+    lmsGetValue(CMIElement: string): string;
+    lmsSetValue(CMIElement: string, value: any): string;
+    lmsCommit(): string;
+    lmsGetLastError(): string;
+    lmsGetErrorString(CMIErrorCode: string | number): string;
+    lmsGetDiagnostic(CMIErrorCode: string | number): string;
+    storeData(_calculateTotalTime: boolean): Promise<ResultObject>;
+    renderCommitCMI(_terminateCommit: boolean): RefObject | Array<any>;
+    getLmsErrorMessageDetails(_errorNumber: string | number, _detail?: boolean): string;
+    getCMIValue(_CMIElement: string): string;
+    setCMIValue(_CMIElement: string, _value: any): string;
+    validateCorrectResponse(_CMIElement: string, _value: any): void;
+    getChildElement(_CMIElement: string, _value: any, _foundFirstIndex: boolean): BaseCMI | null;
+}

package/dist/types/types/api_types.d.ts

@@ -0,0 +1,73 @@
+import { CompletionStatus, LogLevelEnum, SuccessStatus } from "../constants/enums";
+export type Settings = {
+    autocommit?: boolean;
+    autocommitSeconds?: number;
+    asyncCommit?: boolean;
+    sendFullCommit?: boolean;
+    lmsCommitUrl?: boolean | string;
+    dataCommitFormat?: string;
+    commitRequestDataType?: string;
+    autoProgress?: boolean;
+    logLevel?: LogLevel;
+    selfReportSessionTime?: boolean;
+    alwaysSendTotalTime?: boolean;
+    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: LogLevel, logMessage: string) => void;
+    mastery_override?: boolean;
+    renderCommonCommitFields?: boolean;
+    scoItemIds?: string[];
+    scoItemIdValidator?: false | ((scoItemId: string) => boolean);
+    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;
+};
+export type ResultObject = {
+    result: string;
+    errorCode: number;
+    navRequest?: string;
+};
+export type ScoreObject = {
+    raw?: number;
+    min?: number;
+    max?: number;
+    scaled?: number;
+};
+export type CommitObject = {
+    successStatus: SuccessStatus;
+    completionStatus: CompletionStatus;
+    totalTimeSeconds: number;
+    runtimeData: RefObject;
+    score?: ScoreObject;
+};
+export type LogLevel = 1 | 2 | 3 | 4 | 5 | "1" | "2" | "3" | "4" | "5" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "NONE" | LogLevelEnum;

package/dist/types/utilities.d.ts

@@ -0,0 +1,19 @@
+export declare const SECONDS_PER_SECOND = 1;
+export declare const SECONDS_PER_MINUTE = 60;
+export declare const SECONDS_PER_HOUR: number;
+export declare const SECONDS_PER_DAY: number;
+type StringKeyMap = {
+    [key: string]: any;
+};
+export declare function getSecondsAsHHMMSS(totalSeconds: number | null): string;
+export declare function getSecondsAsISODuration(seconds: number | null): string;
+export declare function getTimeAsSeconds(timeString: string | number | boolean | null, timeRegex: RegExp | string): number;
+export declare function getDurationAsSeconds(duration: string | null, durationRegex: RegExp | string): number;
+export declare function addTwoDurations(first: string, second: string, durationRegex: RegExp | string): string;
+export declare function addHHMMSSTimeStrings(first: string, second: string, timeRegex: RegExp | string): string;
+export declare function flatten(data: StringKeyMap): object;
+export declare function unflatten(data: StringKeyMap): object;
+export declare function countDecimals(num: number): number;
+export declare function formatMessage(functionName: string, message: string, CMIElement?: string): string;
+export declare function stringMatches(str: string, tester: string): boolean;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scorm-again",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "A modern SCORM JavaScript run-time library for AICC, SCORM 1.2, and SCORM 2004",
   "main": "dist/scorm-again.js",
   "types": "index.d.ts",
@@ -65,10 +65,11 @@
     "webpack": "^5.97.1",
     "webpack-cli": "^5.1.4"
   },
+  "sideEffects": false,
   "scripts": {
     "test": "./node_modules/.bin/mocha --import=tsx --bdd --recursive --reporter list",
     "test:coverage": "./node_modules/.bin/c8 ./node_modules/.bin/mocha --import=tsx --recursive --timeout=10000 --exit --reporter json --reporter-option output=test-results.json",
-    "compile": "./node_modules/.bin/webpack --bail --config webpack.config.js --mode production",
+    "compile": "./node_modules/.bin/webpack --bail --config webpack.config.js --mode production && tsc --emitDeclarationOnly --declaration --outDir dist/types",
     "fix": "./node_modules/.bin/eslint ./src --fix",
     "prettier": "./node_modules/.bin/prettier --write src/**/*.ts test/**/*.ts src/*.ts test/*.ts"
   },

package/src/BaseAPI.ts

@@ -4,7 +4,7 @@ import { ErrorCode } from "./constants/error_codes";
 import { global_constants } from "./constants/api_constants";
 import { formatMessage, stringMatches, unflatten } from "./utilities";
 import { BaseCMI } from "./cmi/common/base_cmi";
-import { CommitObject, LogLevel, RefObject, ResultObject, Settings } from "./types/api_types";
+import { CommitObject, InternalSettings, LogLevel, RefObject, ResultObject, Settings } from "./types/api_types";
 import { DefaultSettings } from "./constants/default_settings";
 import { IBaseAPI } from "./interfaces/IBaseAPI";
 import { ScheduledCommit } from "./helpers/scheduled_commit";
@@ -15,9 +15,9 @@ import { LogLevelEnum } from "./constants/enums";
  * abstract, and never initialized on its own.
  */
 export default abstract class BaseAPI implements IBaseAPI {
-  private _timeout?: ScheduledCommit;
+  private _timeout?: ScheduledCommit | undefined;
   private readonly _error_codes: ErrorCode;
-  private _settings: Settings = DefaultSettings;
+  private _settings: InternalSettings = DefaultSettings;
 
   /**
    * Constructor for Base API class. Sets some shared API fields, as well as
@@ -36,14 +36,13 @@ export default abstract class BaseAPI implements IBaseAPI {
     this._error_codes = error_codes;
 
     if (settings) {
-      this.settings = settings;
-    }
-    this.apiLogLevel = this.settings.logLevel;
-    this.selfReportSessionTime = this.settings.selfReportSessionTime;
-
-    if (this.apiLogLevel === undefined) {
-      this.apiLogLevel = LogLevelEnum.NONE;
+      this.settings = {
+        ...DefaultSettings,
+        ...settings,
+      } as InternalSettings;
     }
+    this.apiLogLevel = this.settings.logLevel ?? LogLevelEnum.ERROR;
+    this.selfReportSessionTime = this.settings.selfReportSessionTime ?? false;
   }
 
   public abstract cmi: BaseCMI;
@@ -71,7 +70,7 @@ export default abstract class BaseAPI implements IBaseAPI {
     this.currentState = global_constants.STATE_NOT_INITIALIZED;
     this.lastErrorCode = "0";
     this.listenerArray = [];
-    this.startingData = undefined;
+    this.startingData = {};
   }
 
   /**
@@ -209,7 +208,7 @@ export default abstract class BaseAPI implements IBaseAPI {
    * Getter for _settings
    * @return {Settings}
    */
-  get settings(): Settings {
+  get settings(): InternalSettings {
     return this._settings;
   }
 
@@ -1139,7 +1138,7 @@ export default abstract class BaseAPI implements IBaseAPI {
     const process = async (
       url: string,
       params: CommitObject | RefObject | Array<any>,
-      settings: Settings,
+      settings: InternalSettings,
     ): Promise<ResultObject> => {
       try {
         params = settings.requestHandler(params);
@@ -1258,7 +1257,7 @@ export default abstract class BaseAPI implements IBaseAPI {
     url: string,
     params: RefObject | Array<any>,
   ): Promise<Response> {
-    return fetch(url, {
+    let init = {
       method: "POST",
       mode: this.settings.fetchMode,
       body: params instanceof Array ? params.join("&") : JSON.stringify(params),
@@ -1266,9 +1265,17 @@ export default abstract class BaseAPI implements IBaseAPI {
         ...this.settings.xhrHeaders,
         "Content-Type": this.settings.commitRequestDataType,
       },
-      credentials: this.settings.xhrWithCredentials ? "include" : undefined,
       keepalive: true,
-    });
+    } as RequestInit;
+
+    if (this.settings.xhrWithCredentials) {
+      init = {
+        ...init,
+        credentials: "include",
+      };
+    }
+
+    return fetch(url, init);
   }
 
   /**

package/src/Scorm12API.ts

@@ -354,10 +354,8 @@ class Scorm12Impl extends BaseAPI {
     }
 
     const score = this.cmi.core.score;
-    let scoreObject: ScoreObject = null;
+    const scoreObject: ScoreObject = {};
     if (score) {
-      scoreObject = {};
-
       if (!Number.isNaN(Number.parseFloat(score.raw))) {
         scoreObject.raw = Number.parseFloat(score.raw);
       }

package/src/Scorm2004API.ts

@@ -159,13 +159,18 @@ class Scorm2004Impl extends BaseAPI {
       "^adl\\.nav\\.request_valid\\.(choice|jump)\\.{target=\\S{0,}([a-zA-Z0-9-_]+)}$";
     if (stringMatches(CMIElement, adlNavRequestRegex)) {
       const matches = CMIElement.match(adlNavRequestRegex);
-      const request = matches[1];
-      const target = matches[2].replace("{target=", "").replace("}", "");
-      if (request === "choice" || request === "jump") {
-        if (this.settings.scoItemIdValidator) {
-          return String(this.settings.scoItemIdValidator(target));
+      if (matches) {
+        const request = matches[1];
+        const target = matches[2].replace("{target=", "").replace("}", "");
+        if (request === "choice" || request === "jump") {
+          if (this.settings.scoItemIdValidator) {
+            return String(this.settings.scoItemIdValidator(target));
+          }
+          if (this.settings.scoItemIds) {
+            return String(this.settings.scoItemIds?.includes(target));
+          }
+          return String(request);
         }
-        return String(this.settings.scoItemIds.includes(target));
       }
     }
     return this.getValue("GetValue", true, CMIElement);
@@ -257,7 +262,8 @@ class Scorm2004Impl extends BaseAPI {
 
       // Check if the objective ID matches a global objective
       const is_global =
-        objective_id && this.settings.globalObjectiveIds.includes(objective_id);
+        objective_id &&
+        this.settings.globalObjectiveIds?.includes(objective_id);
 
       if (is_global) {
         // Locate or create an entry in _globalObjectives for the global objective
@@ -717,10 +723,8 @@ class Scorm2004Impl extends BaseAPI {
     }
 
     const score = this.cmi.score;
-    let scoreObject: ScoreObject = null;
+    const scoreObject: ScoreObject = {};
     if (score) {
-      scoreObject = {};
-
       if (!Number.isNaN(Number.parseFloat(score.raw))) {
         scoreObject.raw = Number.parseFloat(score.raw);
       }

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;
@@ -538,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"
+  ]
+}