scorm-again 2.0.0 → 2.1.0

package/src/cmi/scorm12/objectives.ts

@@ -0,0 +1,112 @@
+import {BaseCMI} from "../common/base_cmi";
+import {CMIScore} from "../common/score";
+import APIConstants from "../../constants/api_constants";
+import Regex from "../../constants/regex";
+import ErrorCodes from "../../constants/error_codes";
+import {Scorm12ValidationError} from "../../exceptions";
+import {check12ValidFormat} from "./validation";
+import {CMIArray} from "../common/array";
+
+/**
+ * Class representing SCORM 1.2's `cmi.objectives` object
+ * @extends CMIArray
+ */
+export class CMIObjectives extends CMIArray {
+  /**
+   * Constructor for `cmi.objectives`
+   */
+  constructor() {
+    super({
+      children: APIConstants.scorm12.objectives_children,
+      errorCode: ErrorCodes.scorm12.INVALID_SET_VALUE,
+      errorClass: Scorm12ValidationError,
+    });
+  }
+}
+
+/**
+ * Class representing SCORM 1.2's cmi.objectives.n object
+ * @extends BaseCMI
+ */
+export class CMIObjectivesObject extends BaseCMI {
+  /**
+   * Constructor for cmi.objectives.n
+   */
+  constructor() {
+    super();
+    this.score = new CMIScore({
+      score_children: APIConstants.scorm12.score_children,
+      score_range: Regex.scorm12.score_range,
+      invalidErrorCode: ErrorCodes.scorm12.INVALID_SET_VALUE,
+      invalidTypeCode: ErrorCodes.scorm12.TYPE_MISMATCH,
+      invalidRangeCode: ErrorCodes.scorm12.VALUE_OUT_OF_RANGE,
+      errorClass: Scorm12ValidationError,
+    });
+  }
+
+  public readonly score: CMIScore;
+
+  private _id = "";
+  private _status = "";
+
+  /**
+   * Getter for _id
+   * @return {string}
+   */
+  get id(): string {
+    return this._id;
+  }
+
+  /**
+   * Setter for _id
+   * @param {string} id
+   */
+  set id(id: string) {
+    if (check12ValidFormat(id, Regex.scorm12.CMIIdentifier)) {
+      this._id = id;
+    }
+  }
+
+  /**
+   * Getter for _status
+   * @return {string}
+   */
+  get status(): string {
+    return this._status;
+  }
+
+  /**
+   * Setter for _status
+   * @param {string} status
+   */
+  set status(status: string) {
+    if (check12ValidFormat(status, Regex.scorm12.CMIStatus2)) {
+      this._status = status;
+    }
+  }
+
+  /**
+   * toJSON for cmi.objectives.n
+   * @return {
+   *    {
+   *      id: string,
+   *      status: string,
+   *      score: CMIScore
+   *    }
+   *  }
+   */
+  toJSON(): {
+    id: string;
+    status: string;
+    score: CMIScore;
+  } {
+    this.jsonString = true;
+    const result = {
+      id: this.id,
+      status: this.status,
+      score: this.score,
+    };
+    delete this.jsonString;
+    return result;
+  }
+}

package/src/cmi/scorm12/student_data.ts

@@ -0,0 +1,130 @@
+import { BaseCMI } from "../common/base_cmi";
+import APIConstants from "../../constants/api_constants";
+import { Scorm12ValidationError } from "../../exceptions";
+import ErrorCodes from "../../constants/error_codes";
+
+/**
+ * Class representing the SCORM 1.2 cmi.student_data object
+ * @extends BaseCMI
+ */
+export class CMIStudentData extends BaseCMI {
+  private readonly __children;
+  private _mastery_score = "";
+  private _max_time_allowed = "";
+  private _time_limit_action = "";
+
+  /**
+   * Constructor for cmi.student_data
+   * @param {string} student_data_children
+   */
+  constructor(student_data_children?: string) {
+    super();
+    this.__children = student_data_children
+      ? student_data_children
+      : APIConstants.scorm12.student_data_children;
+  }
+
+  /**
+   * Getter for __children
+   * @return {string}
+   * @private
+   */
+  get _children(): string {
+    return this.__children;
+  }
+
+  /**
+   * Setter for __children. Just throws an error.
+   * @param {string} _children
+   * @private
+   */
+  set _children(_children: string) {
+    throw new Scorm12ValidationError(ErrorCodes.scorm12.INVALID_SET_VALUE);
+  }
+
+  /**
+   * Getter for _master_score
+   * @return {string}
+   */
+  get mastery_score(): string {
+    return this._mastery_score;
+  }
+
+  /**
+   * Setter for _master_score. Can only be called before  initialization.
+   * @param {string} mastery_score
+   */
+  set mastery_score(mastery_score: string) {
+    if (this.initialized) {
+      throw new Scorm12ValidationError(ErrorCodes.scorm12.READ_ONLY_ELEMENT);
+    } else {
+      this._mastery_score = mastery_score;
+    }
+  }
+
+  /**
+   * Getter for _max_time_allowed
+   * @return {string}
+   */
+  get max_time_allowed(): string {
+    return this._max_time_allowed;
+  }
+
+  /**
+   * Setter for _max_time_allowed. Can only be called before  initialization.
+   * @param {string} max_time_allowed
+   */
+  set max_time_allowed(max_time_allowed: string) {
+    if (this.initialized) {
+      throw new Scorm12ValidationError(ErrorCodes.scorm12.READ_ONLY_ELEMENT);
+    } else {
+      this._max_time_allowed = max_time_allowed;
+    }
+  }
+
+  /**
+   * Getter for _time_limit_action
+   * @return {string}
+   */
+  get time_limit_action(): string {
+    return this._time_limit_action;
+  }
+
+  /**
+   * Setter for _time_limit_action. Can only be called before  initialization.
+   * @param {string} time_limit_action
+   */
+  set time_limit_action(time_limit_action: string) {
+    if (this.initialized) {
+      throw new Scorm12ValidationError(ErrorCodes.scorm12.READ_ONLY_ELEMENT);
+    } else {
+      this._time_limit_action = time_limit_action;
+    }
+  }
+
+  /**
+   * toJSON for cmi.student_data
+   *
+   * @return {
+   *    {
+   *      max_time_allowed: string,
+   *      time_limit_action: string,
+   *      mastery_score: string
+   *    }
+   *  }
+   */
+  toJSON(): {
+    mastery_score: string;
+    max_time_allowed: string;
+    time_limit_action: string;
+  } {
+    this.jsonString = true;
+    const result = {
+      mastery_score: this.mastery_score,
+      max_time_allowed: this.max_time_allowed,
+      time_limit_action: this.time_limit_action,
+    };
+    delete this.jsonString;
+    return result;
+  }
+}

package/src/cmi/scorm12/student_preference.ts

@@ -0,0 +1,158 @@
+import { BaseCMI } from "../common/base_cmi";
+import APIConstants from "../../constants/api_constants";
+import { Scorm12ValidationError } from "../../exceptions";
+import ErrorCodes from "../../constants/error_codes";
+import { check12ValidFormat, check12ValidRange } from "./validation";
+import Regex from "../../constants/regex";
+
+/**
+ * Class representing the SCORM 1.2 cmi.student_preference object
+ * @extends BaseCMI
+ */
+export class CMIStudentPreference extends BaseCMI {
+  private readonly __children;
+
+  /**
+   * Constructor for cmi.student_preference
+   * @param {string} student_preference_children
+   */
+  constructor(student_preference_children?: string) {
+    super();
+    this.__children = student_preference_children
+      ? student_preference_children
+      : APIConstants.scorm12.student_preference_children;
+  }
+
+  private _audio = "";
+  private _language = "";
+  private _speed = "";
+  private _text = "";
+
+  /**
+   * Getter for __children
+   * @return {string}
+   * @private
+   */
+  get _children(): string {
+    return this.__children;
+  }
+
+  /**
+   * Setter for __children. Just throws an error.
+   * @param {string} _children
+   * @private
+   */
+  set _children(_children: string) {
+    throw new Scorm12ValidationError(ErrorCodes.scorm12.INVALID_SET_VALUE);
+  }
+
+  /**
+   * Getter for _audio
+   * @return {string}
+   */
+  get audio(): string {
+    return this._audio;
+  }
+
+  /**
+   * Setter for _audio
+   * @param {string} audio
+   */
+  set audio(audio: string) {
+    if (
+      check12ValidFormat(audio, Regex.scorm12.CMISInteger) &&
+      check12ValidRange(audio, Regex.scorm12.audio_range)
+    ) {
+      this._audio = audio;
+    }
+  }
+
+  /**
+   * Getter for _language
+   * @return {string}
+   */
+  get language(): string {
+    return this._language;
+  }
+
+  /**
+   * Setter for _language
+   * @param {string} language
+   */
+  set language(language: string) {
+    if (check12ValidFormat(language, Regex.scorm12.CMIString256)) {
+      this._language = language;
+    }
+  }
+
+  /**
+   * Getter for _speed
+   * @return {string}
+   */
+  get speed(): string {
+    return this._speed;
+  }
+
+  /**
+   * Setter for _speed
+   * @param {string} speed
+   */
+  set speed(speed: string) {
+    if (
+      check12ValidFormat(speed, Regex.scorm12.CMISInteger) &&
+      check12ValidRange(speed, Regex.scorm12.speed_range)
+    ) {
+      this._speed = speed;
+    }
+  }
+
+  /**
+   * Getter for _text
+   * @return {string}
+   */
+  get text(): string {
+    return this._text;
+  }
+
+  /**
+   * Setter for _text
+   * @param {string} text
+   */
+  set text(text: string) {
+    if (
+      check12ValidFormat(text, Regex.scorm12.CMISInteger) &&
+      check12ValidRange(text, Regex.scorm12.text_range)
+    ) {
+      this._text = text;
+    }
+  }
+
+  /**
+   * toJSON for cmi.student_preference
+   *
+   * @return {
+   *    {
+   *      audio: string,
+   *      language: string,
+   *      speed: string,
+   *      text: string
+   *    }
+   *  }
+   */
+  toJSON(): {
+    audio: string;
+    language: string;
+    speed: string;
+    text: string;
+  } {
+    this.jsonString = true;
+    const result = {
+      audio: this.audio,
+      language: this.language,
+      speed: this.speed,
+      text: this.text,
+    };
+    delete this.jsonString;
+    return result;
+  }
+}

package/src/cmi/scorm12/validation.ts

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

package/src/cmi/scorm2004/adl.ts

@@ -0,0 +1,272 @@
+import { BaseCMI } from "../common/base_cmi";
+import { Scorm2004ValidationError } from "../../exceptions";
+import ErrorCodes from "../../constants/error_codes";
+import { check2004ValidFormat } from "./validation";
+import Regex from "../../constants/regex";
+import { NAVBoolean } from "../../constants/enums";
+
+/**
+ * Class representing SCORM 2004's adl object
+ */
+export class ADL extends BaseCMI {
+  /**
+   * Constructor for adl
+   */
+  constructor() {
+    super();
+    this.nav = new ADLNav();
+  }
+
+  public nav: ADLNav;
+
+  /**
+   * Called when the API has been initialized after the CMI has been created
+   */
+  initialize() {
+    super.initialize();
+    this.nav?.initialize();
+  }
+
+  /**
+   * toJSON for adl
+   * @return {
+   *    {
+   *      nav: ADLNav
+   *    }
+   *  }
+   */
+  toJSON(): {
+    nav: ADLNav;
+  } {
+    this.jsonString = true;
+    const result = {
+      nav: this.nav,
+    };
+    delete this.jsonString;
+    return result;
+  }
+}
+
+/**
+ * Class representing SCORM 2004's `adl.nav` object
+ */
+
+export class ADLNav extends BaseCMI {
+  private _request = "_none_";
+
+  /**
+   * Constructor for `adl.nav`
+   */
+  constructor() {
+    super();
+    this.request_valid = new ADLNavRequestValid();
+  }
+
+  public request_valid: ADLNavRequestValid;
+
+  /**
+   * Called when the API has been initialized after the CMI has been created
+   */
+  initialize() {
+    super.initialize();
+    this.request_valid?.initialize();
+  }
+
+  /**
+   * Getter for _request
+   * @return {string}
+   */
+  get request(): string {
+    return this._request;
+  }
+
+  /**
+   * Setter for _request
+   * @param {string} request
+   */
+  set request(request: string) {
+    if (check2004ValidFormat(request, Regex.scorm2004.NAVEvent)) {
+      this._request = request;
+    }
+  }
+
+  /**
+   * toJSON for adl.nav
+   *
+   * @return {
+   *    {
+   *      request: string
+   *    }
+   *  }
+   */
+  toJSON(): {
+    request: string;
+  } {
+    this.jsonString = true;
+    const result = {
+      request: this.request,
+    };
+    delete this.jsonString;
+    return result;
+  }
+}
+
+/**
+ * Class representing SCORM 2004's adl.nav.request_valid object
+ */
+
+export class ADLNavRequestValid extends BaseCMI {
+  private _continue = "unknown";
+  private _previous = "unknown";
+  private _choice: {
+    [key: string]: NAVBoolean;
+  } = {};
+  private _jump: {
+    [key: string]: NAVBoolean;
+  } = {};
+
+  /**
+   * Constructor for adl.nav.request_valid
+   */
+  constructor() {
+    super();
+  }
+
+  /**
+   * Getter for _continue
+   * @return {string}
+   */
+  get continue(): string {
+    return this._continue;
+  }
+
+  /**
+   * Setter for _continue. Just throws an error.
+   * @param {string} _continue
+   */
+  set continue(_continue: string) {
+    if (this.initialized) {
+      throw new Scorm2004ValidationError(
+        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      );
+    }
+    if (check2004ValidFormat(_continue, Regex.scorm2004.NAVBoolean)) {
+      this._continue = _continue;
+    }
+  }
+
+  /**
+   * Getter for _previous
+   * @return {string}
+   */
+  get previous(): string {
+    return this._previous;
+  }
+
+  /**
+   * Setter for _previous. Just throws an error.
+   * @param {string} _previous
+   */
+  set previous(_previous: string) {
+    if (this.initialized) {
+      throw new Scorm2004ValidationError(
+        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      );
+    }
+    if (check2004ValidFormat(_previous, Regex.scorm2004.NAVBoolean)) {
+      this._previous = _previous;
+    }
+  }
+
+  /**
+   * Getter for _choice
+   * @return {{ [key: string]: NAVBoolean }}
+   */
+  get choice(): { [key: string]: NAVBoolean } {
+    return this._choice;
+  }
+
+  /**
+   * Setter for _choice
+   * @param {{ [key: string]: string }} choice
+   */
+  set choice(choice: { [key: string]: string }) {
+    if (this.initialized) {
+      throw new Scorm2004ValidationError(
+        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      );
+    }
+    if (typeof choice !== "object") {
+      throw new Scorm2004ValidationError(ErrorCodes.scorm2004.TYPE_MISMATCH);
+    }
+    for (const key in choice) {
+      if ({}.hasOwnProperty.call(choice, key)) {
+        if (
+          check2004ValidFormat(choice[key], Regex.scorm2004.NAVBoolean) &&
+          check2004ValidFormat(key, Regex.scorm2004.NAVTarget)
+        ) {
+          this._choice[key] =
+            NAVBoolean[choice[key] as keyof typeof NAVBoolean];
+        }
+      }
+    }
+  }
+
+  /**
+   * Getter for _jump
+   * @return {{ [key: string]: NAVBoolean }}
+   */
+  get jump(): { [key: string]: NAVBoolean } {
+    return this._jump;
+  }
+
+  /**
+   * Setter for _jump
+   * @param {{ [key: string]: string }} jump
+   */
+  set jump(jump: { [key: string]: string }) {
+    if (this.initialized) {
+      throw new Scorm2004ValidationError(
+        ErrorCodes.scorm2004.READ_ONLY_ELEMENT,
+      );
+    }
+    if (typeof jump !== "object") {
+      throw new Scorm2004ValidationError(ErrorCodes.scorm2004.TYPE_MISMATCH);
+    }
+    for (const key in jump) {
+      if ({}.hasOwnProperty.call(jump, key)) {
+        if (
+          check2004ValidFormat(jump[key], Regex.scorm2004.NAVBoolean) &&
+          check2004ValidFormat(key, Regex.scorm2004.NAVTarget)
+        ) {
+          this._jump[key] = NAVBoolean[jump[key] as keyof typeof NAVBoolean];
+        }
+      }
+    }
+  }
+
+  /**
+   * toJSON for adl.nav.request_valid
+   *
+   * @return {
+   *    {
+   *      previous: string,
+   *      continue: string
+   *    }
+   *  }
+   */
+  toJSON(): {
+    previous: string;
+    continue: string;
+  } {
+    this.jsonString = true;
+    const result = {
+      previous: this._previous,
+      continue: this._continue,
+      choice: this._choice,
+      jump: this._jump,
+    };
+    delete this.jsonString;
+    return result;
+  }
+}