scorm-again 1.7.1 → 2.1.0

package/test/utilities.spec.ts

@@ -0,0 +1,322 @@
+import { expect } from "expect";
+import { describe, it } from "mocha";
+import * as Utilities from "../src/utilities";
+import Regex from "../src/constants/regex";
+
+const scorm12_regex = Regex.scorm12;
+const scorm2004_regex = Regex.scorm2004;
+
+describe("Utility Tests", () => {
+  describe("getSecondsAsHHMMSS()", () => {
+    it("10 returns 00:00:10", () => {
+      expect(Utilities.getSecondsAsHHMMSS(10)).toEqual("00:00:10");
+    });
+
+    it("60 returns 00:01:00", () => {
+      expect(Utilities.getSecondsAsHHMMSS(60)).toEqual("00:01:00");
+    });
+
+    it("3600 returns 01:00:00", () => {
+      expect(Utilities.getSecondsAsHHMMSS(3600)).toEqual("01:00:00");
+    });
+
+    it("70 returns 00:01:10", () => {
+      expect(Utilities.getSecondsAsHHMMSS(70)).toEqual("00:01:10");
+    });
+
+    it("3670 returns 01:01:10", () => {
+      expect(Utilities.getSecondsAsHHMMSS(3670)).toEqual("01:01:10");
+    });
+
+    it("90000 returns 25:00:00, check for hours greater than 24", () => {
+      expect(Utilities.getSecondsAsHHMMSS(90000)).toEqual("25:00:00");
+    });
+
+    it("-3600 returns 00:00:00, negative time not allowed in SCORM session times", () => {
+      expect(Utilities.getSecondsAsHHMMSS(-3600)).toEqual("00:00:00");
+    });
+
+    it("Empty seconds returns 00:00:00", () => {
+      expect(Utilities.getSecondsAsHHMMSS(null)).toEqual("00:00:00");
+    });
+  });
+
+  describe("getSecondsAsISODuration()", () => {
+    it("10 returns PT10S", () => {
+      expect(Utilities.getSecondsAsISODuration(10)).toEqual("PT10S");
+    });
+
+    it("60 returns PT1M", () => {
+      expect(Utilities.getSecondsAsISODuration(60)).toEqual("PT1M");
+    });
+
+    it("3600 returns PT1H", () => {
+      expect(Utilities.getSecondsAsISODuration(3600)).toEqual("PT1H");
+    });
+
+    it("70 returns PT1M10S", () => {
+      expect(Utilities.getSecondsAsISODuration(70)).toEqual("PT1M10S");
+    });
+
+    it("916.88 returns PT15M16.88S", () => {
+      expect(Utilities.getSecondsAsISODuration(916.88)).toEqual("PT15M16.88S");
+    });
+
+    it("3670 returns PT1H1M10S", () => {
+      expect(Utilities.getSecondsAsISODuration(3670)).toEqual("PT1H1M10S");
+    });
+
+    it("90000 returns P1DT1H", () => {
+      expect(Utilities.getSecondsAsISODuration(90000)).toEqual("P1DT1H");
+    });
+
+    it("90061 returns P1DT1H1M1S", () => {
+      expect(Utilities.getSecondsAsISODuration(90061)).toEqual("P1DT1H1M1S");
+    });
+
+    it("-3600 returns PT0S, negative time not allowed in SCORM session times", () => {
+      expect(Utilities.getSecondsAsISODuration(-3600)).toEqual("PT0S");
+    });
+
+    it("Empty seconds returns PT0S", () => {
+      expect(Utilities.getSecondsAsISODuration(null)).toEqual("PT0S");
+    });
+  });
+
+  describe("getTimeAsSeconds()", () => {
+    it("00:00:10 returns 10", () => {
+      expect(
+        Utilities.getTimeAsSeconds("00:00:10", scorm12_regex.CMITimespan),
+      ).toEqual(10);
+    });
+
+    it("00:01:10 returns 70", () => {
+      expect(
+        Utilities.getTimeAsSeconds("00:01:10", scorm12_regex.CMITimespan),
+      ).toEqual(70);
+    });
+
+    it("01:01:10 returns 3670", () => {
+      expect(
+        Utilities.getTimeAsSeconds("01:01:10", scorm12_regex.CMITimespan),
+      ).toEqual(3670);
+    });
+
+    it("100:00:00 returns 3670", () => {
+      expect(
+        Utilities.getTimeAsSeconds("100:00:00", scorm12_regex.CMITimespan),
+      ).toEqual(360000);
+    });
+
+    it("-01:00:00 returns 0", () => {
+      expect(
+        Utilities.getTimeAsSeconds("-01:00:00", scorm12_regex.CMITimespan),
+      ).toEqual(0);
+    });
+
+    it("Number value returns 0", () => {
+      expect(
+        Utilities.getTimeAsSeconds(999, scorm12_regex.CMITimespan),
+      ).toEqual(0);
+    });
+
+    it("boolean value returns 0", () => {
+      expect(
+        Utilities.getTimeAsSeconds(true, scorm12_regex.CMITimespan),
+      ).toEqual(0);
+    });
+
+    it("Empty value returns 0", () => {
+      expect(
+        Utilities.getTimeAsSeconds(null, scorm12_regex.CMITimespan),
+      ).toEqual(0);
+    });
+  });
+
+  describe("getDurationAsSeconds()", () => {
+    it("P0S returns 0", () => {
+      expect(
+        Utilities.getDurationAsSeconds("P0S", scorm2004_regex.CMITimespan),
+      ).toEqual(0);
+    });
+
+    it("P70S returns 70", () => {
+      expect(
+        Utilities.getDurationAsSeconds("P70S", scorm2004_regex.CMITimespan),
+      ).toEqual(70);
+    });
+
+    it("PT1M10S returns 70", () => {
+      expect(
+        Utilities.getDurationAsSeconds("PT1M10S", scorm2004_regex.CMITimespan),
+      ).toEqual(70);
+    });
+
+    it("PT15M16.88S returns 916.88", () => {
+      expect(
+        Utilities.getDurationAsSeconds(
+          "PT15M16.88S",
+          scorm2004_regex.CMITimespan,
+        ),
+      ).toEqual(916.88);
+    });
+
+    it("P1D returns 86400", () => {
+      expect(
+        Utilities.getDurationAsSeconds("P1D", scorm2004_regex.CMITimespan),
+      ).toEqual(24 * 60 * 60);
+    });
+
+    it("P1Y returns number of seconds for one year from now", () => {
+      expect(
+        Utilities.getDurationAsSeconds("P1Y", scorm2004_regex.CMITimespan),
+      ).toEqual(365 * 24 * 60 * 60);
+    });
+
+    it("Invalid duration returns 0", () => {
+      expect(
+        Utilities.getDurationAsSeconds("T1M10S", scorm2004_regex.CMITimespan),
+      ).toEqual(0);
+    });
+
+    it("Empty duration returns 0", () => {
+      expect(
+        Utilities.getDurationAsSeconds(null, scorm2004_regex.CMITimespan),
+      ).toEqual(0);
+    });
+  });
+
+  describe("addTwoDurations()", () => {
+    it("P1H5M30.5S plus PT15M10S equals P1H20M40.5S", () => {
+      expect(
+        Utilities.addTwoDurations(
+          "PT1H5M30.5S",
+          "PT15M30S",
+          scorm2004_regex.CMITimespan,
+        ),
+      ).toEqual("PT1H21M0.5S");
+    });
+    it("P1Y364D plus P2DT1H45M52S equals P731DT1H45M52S", () => {
+      expect(
+        Utilities.addTwoDurations(
+          "P1Y364D",
+          "P2DT1H45M52S",
+          scorm2004_regex.CMITimespan,
+        ),
+      ).toEqual("P731DT1H45M52S");
+    });
+    it("Invalid plus valid equals valid", () => {
+      expect(
+        Utilities.addTwoDurations(
+          "NOT A VALID DURATION",
+          "PT1H30M45S",
+          scorm2004_regex.CMITimespan,
+        ),
+      ).toEqual("PT1H30M45S");
+    });
+    it("Valid plus invalid equals valid", () => {
+      expect(
+        Utilities.addTwoDurations(
+          "PT1H30M45S",
+          "NOT A VALID DURATION",
+          scorm2004_regex.CMITimespan,
+        ),
+      ).toEqual("PT1H30M45S");
+    });
+  });
+
+  describe("addHHMMSSTimeStrings()", () => {
+    it("01:05:30.5 plus 00:15:10 equals 01:20:40.5", () => {
+      expect(
+        Utilities.addHHMMSSTimeStrings(
+          "01:05:30.5",
+          "00:15:30",
+          scorm12_regex.CMITimespan,
+        ),
+      ).toEqual("01:21:00.5");
+    });
+    it("17496:00:00 plus 49:35:52 equals 17545:35:52", () => {
+      expect(
+        Utilities.addHHMMSSTimeStrings(
+          "17496:00:00",
+          "49:35:52",
+          scorm12_regex.CMITimespan,
+        ),
+      ).toEqual("17545:35:52");
+    });
+    it("Invalid plus valid equals valid", () => {
+      expect(
+        Utilities.addHHMMSSTimeStrings(
+          "-00:15:10",
+          "01:05:30.5",
+          scorm12_regex.CMITimespan,
+        ),
+      ).toEqual("01:05:30.5");
+    });
+    it("Valid plus invalid equals valid", () => {
+      expect(
+        Utilities.addHHMMSSTimeStrings(
+          "01:05:30.5",
+          "NOT A VALID DURATION",
+          scorm12_regex.CMITimespan,
+        ),
+      ).toEqual("01:05:30.5");
+    });
+  });
+
+  describe("flatten()", () => {
+    it("Should return flattened object", () => {
+      expect(
+        Utilities.flatten({
+          cmi: {
+            core: {
+              learner_id: "jputney",
+              learner_name: "Jonathan",
+            },
+            objectives: {
+              "0": {
+                id: "AAA",
+              },
+              "1": {
+                id: "BBB",
+              },
+            },
+          },
+        }),
+      ).toEqual({
+        "cmi.core.learner_id": "jputney",
+        "cmi.core.learner_name": "Jonathan",
+        "cmi.objectives.0.id": "AAA",
+        "cmi.objectives.1.id": "BBB",
+      });
+    });
+  });
+
+  describe("unflatten()", () => {
+    it("Should return flattened object", () => {
+      expect(
+        Utilities.unflatten({
+          "cmi.core.learner_id": "jputney",
+          "cmi.core.learner_name": "Jonathan",
+          "cmi.objectives.0.id": "AAA",
+          "cmi.objectives.1.id": "BBB",
+        }),
+      ).toEqual({
+        cmi: {
+          core: {
+            learner_id: "jputney",
+            learner_name: "Jonathan",
+          },
+          objectives: {
+            "0": {
+              id: "AAA",
+            },
+            "1": {
+              id: "BBB",
+            },
+          },
+        },
+      });
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "declaration": false,
+    "module": "es2015",
+    "moduleResolution": "Node",
+    "target": "es5",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "typeRoots": ["node_modules/@types"],
+    "removeComments": true,
+    "importHelpers": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

package/webpack.config.js

@@ -0,0 +1,65 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import ESLintPlugin from "eslint-webpack-plugin";
+import TerserPlugin from "terser-webpack-plugin";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TSLoader = {
+  test: /\.ts$/i,
+  exclude: /node_modules/,
+  use: {
+    loader: "ts-loader",
+  },
+};
+
+export default {
+  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",
+  },
+  target: ["web", "es5"],
+  module: {
+    rules: [TSLoader],
+  },
+  output: {
+    path: path.resolve(__dirname, "dist"),
+    environment: {
+      arrowFunction: false,
+    },
+  },
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new TerserPlugin({
+        parallel: true,
+        include: /\.min\.js$/,
+        terserOptions: {
+          output: {
+            comments: false,
+          },
+        },
+      }),
+    ],
+  },
+  resolve: {
+    extensions: [".ts", ".js"],
+  },
+  plugins: [
+    new ESLintPlugin({
+      overrideConfigFile: path.resolve(__dirname, "eslint.config.js"),
+      configType: "flat",
+      context: path.resolve(__dirname, "../src"),
+      files: ["**/*.js", "**/*.ts"],
+    }),
+  ],
+};

package/.circleci/config.yml

@@ -1,99 +0,0 @@
-# Javascript Node CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/language-javascript/ for more details
-#
-version: 2
-jobs:
-  build:
-    docker:
-      # specify the version you desire here
-      - image: circleci/node:lts-browsers
-
-      # Specify service dependencies here if necessary
-      # CircleCI maintains a library of pre-built images
-      # documented at https://circleci.com/docs/2.0/circleci-images/
-      # - image: circleci/mongo:3.4.4
-
-    working_directory: ~/scorm-again
-
-    steps:
-      - checkout
-
-      # Download and cache dependencies
-      - restore_cache:
-          keys:
-            - v1-dependencies-{{ checksum "package.json" }}
-            # fallback to using the latest cache if no exact match is found
-            - v1-dependencies-
-
-      - run: yarn install
-
-      - save_cache:
-          paths:
-            - node_modules
-          key: v1-dependencies-{{ checksum "package.json" }}
-
-      - run: mkdir reports dist docs test-results || true
-
-      # Run mocha
-      - run:
-          name: yarn test
-          command: ./node_modules/.bin/nyc ./node_modules/.bin/mocha --require @babel/register --recursive --timeout=10000 --exit --reporter mocha-junit-reporter --reporter-options mochaFile=test-results/mocha/results.xml
-          when: always
-
-      # Run eslint
-      - run:
-          name: eslint
-          command: |
-            ./node_modules/.bin/eslint ./src --format junit --output-file ./reports/eslint/eslint.xml
-          when: always
-
-      # Run coverage report for Code Climate
-      - run:
-          name: Setup Code Climate test-reporter
-          command: |
-            # download test reporter as a static binary
-            curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-            chmod +x ./cc-test-reporter
-            ./cc-test-reporter before-build
-          when: always
-
-      - run:
-          name: code-coverage
-          command: |
-            mkdir coverage
-            # nyc report requires that nyc has already been run,
-            # which creates the .nyc_output folder containing necessary data
-            ./node_modules/.bin/nyc report --reporter=text-lcov > coverage/lcov.info
-            ./cc-test-reporter after-build -t lcov
-          when: always
-
-      # compile documentation
-      - run: ./node_modules/.bin/jsdoc -c .jsdoc.json -d ./docs ./src/
-
-      # run babel compile
-      - run: git config user.email "jputney@noverant.com" && git config user.name "Jonathan Putney"
-      - run: ./node_modules/.bin/webpack --bail --config webpack.js
-      - run: git add --all dist/
-
-      # run jsdoc
-      # - run: ./node_modules/.bin/jsdoc -c .jsdoc.json -d ./docs ./src/
-      # - run: git add --all docs/
-
-      # git commit and push dist and docs
-      - run: git commit -m "[skip ci] - Updating Dist and Docs" && git push origin master || true
-
-      # Upload results
-
-      - store_test_results:
-          path: test-results
-
-      - store_artifacts:
-          path: ./reports/mocha/test-results.xml
-
-      - store_artifacts:
-          path: ./reports/eslint/eslint.xml
-
-      - store_artifacts: # upload test coverage as artifact
-          path: ./coverage/lcov.info
-          prefix: tests

package/.codeclimate.yml

@@ -1,7 +0,0 @@
-plugins:
-  eslint:
-    enabled: true
-    config:
-      config: .eslintrc.js
-  markdownlint:
-    enabled: false

package/.eslintrc.js

@@ -1,36 +0,0 @@
-module.exports = {
-  parser: 'babel-eslint',
-  env: {
-    browser: true,
-    es6: true,
-  },
-  extends: ['eslint:recommended', 'google'],
-  globals: {
-    Atomics: 'readonly',
-    SharedArrayBuffer: 'readonly',
-  },
-  parserOptions: {
-    sourceType: 'module',
-    allowImportExportEverywhere: false,
-    classPrivateMethods: true,
-    ecmaFeatures: {
-      globalReturn: false,
-    },
-    babelOptions: {
-      configFile: './.babelrc',
-    },
-  },
-  rules: {
-    'camelcase': 'off',
-    'max-len': 'off',
-    'no-unused-vars': 'off',
-  },
-  overrides: [
-    {
-      'files': ['*.spec.js'],
-      'rules': {
-        'no-undef': 0,
-      },
-    },
-  ],
-};

package/src/.flowconfig

@@ -1,11 +0,0 @@
-[ignore]
-
-[include]
-
-[libs]
-
-[lints]
-
-[options]
-
-[strict]

package/src/AICC.js

@@ -1,68 +0,0 @@
-// @flow
-import Scorm12API from './Scorm12API';
-import {
-  CMI,
-  CMIAttemptRecordsObject,
-  CMIEvaluationCommentsObject,
-  CMITriesObject,
-} from './cmi/aicc_cmi';
-import {NAV} from './cmi/scorm12_cmi';
-
-/**
- * The AICC API class
- */
-export default class AICC extends Scorm12API {
-  /**
-   * Constructor to create AICC API object
-   * @param {object} settings
-   */
-  constructor(settings: {}) {
-    const finalSettings = {
-      ...{
-        mastery_override: false,
-      }, ...settings,
-    };
-
-    super(finalSettings);
-
-    this.cmi = new CMI();
-    this.nav = new NAV();
-  }
-
-  /**
-   * Gets or builds a new child element to add to the array.
-   *
-   * @param {string} CMIElement
-   * @param {any} value
-   * @param {boolean} foundFirstIndex
-   * @return {object}
-   */
-  getChildElement(CMIElement, value, foundFirstIndex) {
-    let newChild = super.getChildElement(CMIElement, value, foundFirstIndex);
-
-    if (!newChild) {
-      if (this.stringMatches(CMIElement, 'cmi\\.evaluation\\.comments\\.\\d+')) {
-        newChild = new CMIEvaluationCommentsObject();
-      } else if (this.stringMatches(CMIElement,
-          'cmi\\.student_data\\.tries\\.\\d+')) {
-        newChild = new CMITriesObject();
-      } else if (this.stringMatches(CMIElement,
-          'cmi\\.student_data\\.attempt_records\\.\\d+')) {
-        newChild = new CMIAttemptRecordsObject();
-      }
-    }
-
-    return newChild;
-  }
-
-  /**
-   * Replace the whole API with another
-   *
-   * @param {AICC} newAPI
-   */
-  replaceWithAnotherScormAPI(newAPI) {
-    // Data Model
-    this.cmi = newAPI.cmi;
-    this.nav = newAPI.nav;
-  }
-}