scorm-again 1.7.0 → 2.0.0

package/src/exceptions.ts

@@ -0,0 +1,133 @@
+import APIConstants from "./constants/api_constants";
+import { BaseScormValidationError } from "./cmi/common";
+
+const scorm12_errors = APIConstants.scorm12.error_descriptions;
+const aicc_errors = APIConstants.aicc.error_descriptions;
+const scorm2004_errors = APIConstants.scorm2004.error_descriptions;
+
+type APIError = {
+  errorCode: number;
+  errorMessage: string;
+  detailedMessage: string;
+};
+
+/**
+ * Base Validation Exception
+ */
+export class ValidationError
+  extends BaseScormValidationError
+  implements APIError
+{
+  /**
+   * Constructor to take in an error message and code
+   * @param {number} errorCode
+   * @param {string} errorMessage
+   * @param {string} detailedMessage
+   */
+  constructor(
+    errorCode: number,
+    errorMessage: string,
+    detailedMessage?: string,
+  ) {
+    super(errorCode);
+    this.setMessage(errorMessage);
+    this._errorMessage = errorMessage;
+    if (detailedMessage) {
+      this._detailedMessage = detailedMessage;
+    }
+  }
+
+  private readonly _errorMessage: string;
+  private readonly _detailedMessage: string = "";
+
+  /**
+   * Getter for _errorMessage
+   * @return {string}
+   */
+  get errorMessage(): string {
+    return this._errorMessage;
+  }
+
+  /**
+   * Getter for _detailedMessage
+   * @return {string}
+   */
+  get detailedMessage(): string {
+    return this._detailedMessage;
+  }
+}
+
+/**
+ * SCORM 1.2 Validation Error
+ */
+export class Scorm12ValidationError extends ValidationError {
+  /**
+   * Constructor to take in an error code
+   * @param {number} errorCode
+   */
+  constructor(errorCode: number) {
+    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {
+      super(
+        errorCode,
+        scorm12_errors[String(errorCode)].basicMessage,
+        scorm12_errors[String(errorCode)].detailMessage,
+      );
+    } else {
+      super(
+        101,
+        scorm12_errors["101"].basicMessage,
+        scorm12_errors["101"].detailMessage,
+      );
+    }
+  }
+}
+
+/**
+ * AICC Validation Error
+ */
+export class AICCValidationError extends ValidationError {
+  /**
+   * Constructor to take in an error code
+   * @param {number} errorCode
+   */
+  constructor(errorCode: number) {
+    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {
+      super(
+        errorCode,
+        aicc_errors[String(errorCode)].basicMessage,
+        aicc_errors[String(errorCode)].detailMessage,
+      );
+    } else {
+      super(
+        101,
+        aicc_errors["101"].basicMessage,
+        aicc_errors["101"].detailMessage,
+      );
+    }
+  }
+}
+
+/**
+ * SCORM 2004 Validation Error
+ */
+export class Scorm2004ValidationError extends ValidationError {
+  /**
+   * Constructor to take in an error code
+   * @param {number} errorCode
+   */
+  constructor(errorCode: number) {
+    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {
+      super(
+        errorCode,
+        scorm2004_errors[String(errorCode)].basicMessage,
+        scorm2004_errors[String(errorCode)].detailMessage,
+      );
+    } else {
+      super(
+        101,
+        scorm2004_errors["101"].basicMessage,
+        scorm2004_errors["101"].detailMessage,
+      );
+    }
+  }
+}

package/src/exports/aicc.js

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

package/src/exports/scorm-again.js

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

package/src/exports/scorm12.js

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

package/src/exports/scorm2004.js

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

package/src/{utilities.js → utilities.ts}

@@ -1,87 +1,101 @@
-// @flow
 export const SECONDS_PER_SECOND = 1.0;
 export const SECONDS_PER_MINUTE = 60;
 export const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;
 export const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;
 
-const designations = [
-  ['D', SECONDS_PER_DAY],
-  ['H', SECONDS_PER_HOUR],
-  ['M', SECONDS_PER_MINUTE],
-  ['S', SECONDS_PER_SECOND],
-];
+type Designation = {
+  [key: string]: number;
+};
+
+type StringKeyMap = {
+  [key: string]: any;
+};
+
+const designations: Designation = {
+  D: SECONDS_PER_DAY,
+  H: SECONDS_PER_HOUR,
+  M: SECONDS_PER_MINUTE,
+  S: SECONDS_PER_SECOND,
+};
 
 /**
  * Converts a Number to a String of HH:MM:SS
  *
- * @param {Number} totalSeconds
+ * @param {number} totalSeconds
  * @return {string}
  */
-export function getSecondsAsHHMMSS(totalSeconds: Number) {
+export function getSecondsAsHHMMSS(totalSeconds: number | null): string {
   // SCORM spec does not deal with negative durations, give zero back
   if (!totalSeconds || totalSeconds <= 0) {
-    return '00:00:00';
+    return "00:00:00";
   }
 
   const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);
-
   const dateObj = new Date(totalSeconds * 1000);
   const minutes = dateObj.getUTCMinutes();
   // make sure we add any possible decimal value
   const seconds = dateObj.getSeconds();
   const ms = totalSeconds % 1.0;
-  let msStr = '';
+  let msStr = "";
+
   if (countDecimals(ms) > 0) {
     if (countDecimals(ms) > 2) {
       msStr = ms.toFixed(2);
     } else {
       msStr = String(ms);
     }
-    msStr = '.' + msStr.split('.')[1];
+
+    msStr = "." + msStr.split(".")[1];
   }
 
-  return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g,
-      '0$&') + msStr;
+  return (
+    (hours + ":" + minutes + ":" + seconds).replace(/\b\d\b/g, "0$&") + msStr
+  );
 }
 
 /**
  * Calculate the number of seconds from ISO 8601 Duration
  *
- * @param {Number} seconds
- * @return {String}
+ * @param {number} seconds
+ * @return {string}
  */
-export function getSecondsAsISODuration(seconds: Number) {
+export function getSecondsAsISODuration(seconds: number | null): string {
   // SCORM spec does not deal with negative durations, give zero back
   if (!seconds || seconds <= 0) {
-    return 'PT0S';
+    return "PT0S";
   }
 
-  let duration = 'P';
+  let duration = "P";
   let remainder = seconds;
-
-  designations.forEach(([sign, current_seconds]) => {
+  for (const designationsKey in designations) {
+    const current_seconds = designations[designationsKey];
     let value = Math.floor(remainder / current_seconds);
-
     remainder = remainder % current_seconds;
+
     if (countDecimals(remainder) > 2) {
       remainder = Number(Number(remainder).toFixed(2));
     }
+
     // If we have anything left in the remainder, and we're currently adding
     // seconds to the duration, go ahead and add the decimal to the seconds
-    if (sign === 'S' && remainder > 0) {
+    if (designationsKey === "S" && remainder > 0) {
       value += remainder;
     }
 
     if (value) {
-      if ((duration.indexOf('D') > 0 ||
-          sign === 'H' || sign === 'M' || sign === 'S') &&
-          duration.indexOf('T') === -1) {
-        duration += 'T';
+      if (
+        (duration.indexOf("D") > 0 ||
+          designationsKey === "H" ||
+          designationsKey === "M" ||
+          designationsKey === "S") &&
+        duration.indexOf("T") === -1
+      ) {
+        duration += "T";
       }
-      duration += `${value}${sign}`;
-    }
-  });
 
+      duration += `${value}${designationsKey}`;
+    }
+  }
   return duration;
 }
 
@@ -92,16 +106,25 @@ export function getSecondsAsISODuration(seconds: Number) {
  * @param {RegExp} timeRegex
  * @return {number}
  */
-export function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {
-  if (!timeString || typeof timeString !== 'string' ||
-      !timeString.match(timeRegex)) {
+export function getTimeAsSeconds(
+  timeString: string | number | boolean | null,
+  timeRegex: RegExp | string,
+): number {
+  if (typeof timeString === "number" || typeof timeString === "boolean") {
+    timeString = String(timeString);
+  }
+  if (typeof timeRegex === "string") {
+    timeRegex = new RegExp(timeRegex);
+  }
+  if (!timeString || !timeString.match(timeRegex)) {
     return 0;
   }
-  const parts = timeString.split(':');
+
+  const parts = timeString.split(":");
   const hours = Number(parts[0]);
   const minutes = Number(parts[1]);
   const seconds = Number(parts[2]);
-  return (hours * 3600) + (minutes * 60) + seconds;
+  return hours * 3600 + minutes * 60 + seconds;
 }
 
 /**
@@ -111,22 +134,26 @@ export function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {
  * @param {RegExp} durationRegex
  * @return {number}
  */
-export function getDurationAsSeconds(duration: String, durationRegex: RegExp) {
+export function getDurationAsSeconds(
+  duration: string | null,
+  durationRegex: RegExp | string,
+): number {
+  if (typeof durationRegex === "string") {
+    durationRegex = new RegExp(durationRegex);
+  }
+
   if (!duration || !duration.match(durationRegex)) {
     return 0;
   }
 
-  const [, years, months, , days, hours, minutes, seconds] = new RegExp(
-      durationRegex).exec(duration) || [];
-
+  const [, years, _, , days, hours, minutes, seconds] =
+    new RegExp(durationRegex).exec(duration) || [];
   let result = 0.0;
-
-  result += (Number(seconds) * 1.0 || 0.0);
-  result += (Number(minutes) * 60.0 || 0.0);
-  result += (Number(hours) * 3600.0 || 0.0);
-  result += (Number(days) * (60 * 60 * 24.0) || 0.0);
-  result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);
-
+  result += Number(seconds) || 0.0;
+  result += Number(minutes) * 60.0 || 0.0;
+  result += Number(hours) * 3600.0 || 0.0;
+  result += Number(days) * (60 * 60 * 24.0) || 0.0;
+  result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0;
   return result;
 }
 
@@ -135,16 +162,20 @@ export function getDurationAsSeconds(duration: String, durationRegex: RegExp) {
  *
  * @param {string} first
  * @param {string} second
- * @param {RegExp} durationRegex
+ * @param {RegExp|string} durationRegex
  * @return {string}
  */
 export function addTwoDurations(
-    first: String,
-    second: String,
-    durationRegex: RegExp) {
+  first: string,
+  second: string,
+  durationRegex: RegExp | string,
+): string {
+  const regex: RegExp =
+    typeof durationRegex === "string"
+      ? new RegExp(durationRegex)
+      : durationRegex;
   return getSecondsAsISODuration(
-      getDurationAsSeconds(first, durationRegex) +
-      getDurationAsSeconds(second, durationRegex),
+    getDurationAsSeconds(first, regex) + getDurationAsSeconds(second, regex),
   );
 }
 
@@ -157,13 +188,15 @@ export function addTwoDurations(
  * @return {string}
  */
 export function addHHMMSSTimeStrings(
-    first: String,
-    second: String,
-    timeRegex: RegExp) {
+  first: string,
+  second: string,
+  timeRegex: RegExp | string,
+): string {
+  if (typeof timeRegex === "string") {
+    timeRegex = new RegExp(timeRegex);
+  }
   return getSecondsAsHHMMSS(
-      getTimeAsSeconds(first, timeRegex) +
-      getTimeAsSeconds(
-          second, timeRegex),
+    getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex),
   );
 }
 
@@ -172,35 +205,37 @@ export function addHHMMSSTimeStrings(
  * @param {object} data
  * @return {object}
  */
-export function flatten(data) {
-  const result = {};
+export function flatten(data: StringKeyMap): object {
+  const result: StringKeyMap = {};
 
   /**
    * Recurse through the object
    * @param {*} cur
    * @param {*} prop
    */
-  function recurse(cur, prop) {
+  function recurse(cur: any, prop: any) {
     if (Object(cur) !== cur) {
       result[prop] = cur;
     } else if (Array.isArray(cur)) {
       for (let i = 0, l = cur.length; i < l; i++) {
-        recurse(cur[i], prop + '[' + i + ']');
+        recurse(cur[i], prop + "[" + i + "]");
         if (l === 0) result[prop] = [];
       }
     } else {
       let isEmpty = true;
+
       for (const p in cur) {
         if ({}.hasOwnProperty.call(cur, p)) {
           isEmpty = false;
-          recurse(cur[p], prop ? prop + '.' + p : p);
+          recurse(cur[p], prop ? prop + "." + p : p);
         }
       }
+
       if (isEmpty && prop) result[prop] = {};
     }
   }
 
-  recurse(data, '');
+  recurse(data, "");
   return result;
 }
 
@@ -209,25 +244,30 @@ export function flatten(data) {
  * @param {object} data
  * @return {object}
  */
-export function unflatten(data) {
-  'use strict';
+export function unflatten(data: StringKeyMap): object {
+  "use strict";
+
   if (Object(data) !== data || Array.isArray(data)) return data;
   const regex = /\.?([^.[\]]+)|\[(\d+)]/g;
-  const result = {};
+  const result: StringKeyMap = {};
+
   for (const p in data) {
     if ({}.hasOwnProperty.call(data, p)) {
       let cur = result;
-      let prop = '';
+      let prop = "";
       let m = regex.exec(p);
+
       while (m) {
-        cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));
+        cur = cur[prop] || (cur[prop] = m[2] ? [] : {});
         prop = m[2] || m[1];
         m = regex.exec(p);
       }
+
       cur[prop] = data[p];
     }
   }
-  return result[''] || result;
+
+  return result[""] || result;
 }
 
 /**
@@ -235,8 +275,8 @@ export function unflatten(data) {
  * @param {number} num
  * @return {number}
  */
-export function countDecimals(num: number) {
-  if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;
-  const parts = num.toString().split('.')[1];
+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;
 }

package/tea.yaml

@@ -0,0 +1,6 @@
+# https://tea.xyz/what-is-this-file
+---
+version: 1.0.0
+codeOwners:
+  - '0x1bfc0b2fc65c3eEE1AfFB43E07fbD8F00E18B93E'
+quorum: 1