e7249d9869
- Adds 2 new settings to BaseAPI, xhrWithCredentials and xhrHeaders. - xhrWithCredentials is set to false default to make this a non breaking change but will allow people to set this to try to send Domain Cookies - xhrHeaders gives the ability to add custom headers to the XHR Request to the LMS, allowing additional information to be sent
6903 lines
521 KiB
JavaScript
6903 lines
521 KiB
JavaScript
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
(function (global){(function (){
|
|
/**
|
|
* lodash (Custom Build) <https://lodash.com/>
|
|
* Build: `lodash modularize exports="npm" -o ./`
|
|
* Copyright jQuery Foundation and other contributors <https://jquery.org/>
|
|
* Released under MIT license <https://lodash.com/license>
|
|
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
|
|
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|
*/
|
|
|
|
/** Used as the `TypeError` message for "Functions" methods. */
|
|
var FUNC_ERROR_TEXT = 'Expected a function';
|
|
|
|
/** Used as references for various `Number` constants. */
|
|
var NAN = 0 / 0;
|
|
|
|
/** `Object#toString` result references. */
|
|
var symbolTag = '[object Symbol]';
|
|
|
|
/** Used to match leading and trailing whitespace. */
|
|
var reTrim = /^\s+|\s+$/g;
|
|
|
|
/** Used to detect bad signed hexadecimal string values. */
|
|
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
|
|
|
|
/** Used to detect binary string values. */
|
|
var reIsBinary = /^0b[01]+$/i;
|
|
|
|
/** Used to detect octal string values. */
|
|
var reIsOctal = /^0o[0-7]+$/i;
|
|
|
|
/** Built-in method references without a dependency on `root`. */
|
|
var freeParseInt = parseInt;
|
|
|
|
/** Detect free variable `global` from Node.js. */
|
|
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
|
|
|
|
/** Detect free variable `self`. */
|
|
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
|
|
|
|
/** Used as a reference to the global object. */
|
|
var root = freeGlobal || freeSelf || Function('return this')();
|
|
|
|
/** Used for built-in method references. */
|
|
var objectProto = Object.prototype;
|
|
|
|
/**
|
|
* Used to resolve the
|
|
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
|
|
* of values.
|
|
*/
|
|
var objectToString = objectProto.toString;
|
|
|
|
/* Built-in method references for those with the same name as other `lodash` methods. */
|
|
var nativeMax = Math.max,
|
|
nativeMin = Math.min;
|
|
|
|
/**
|
|
* Gets the timestamp of the number of milliseconds that have elapsed since
|
|
* the Unix epoch (1 January 1970 00:00:00 UTC).
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 2.4.0
|
|
* @category Date
|
|
* @returns {number} Returns the timestamp.
|
|
* @example
|
|
*
|
|
* _.defer(function(stamp) {
|
|
* console.log(_.now() - stamp);
|
|
* }, _.now());
|
|
* // => Logs the number of milliseconds it took for the deferred invocation.
|
|
*/
|
|
var now = function() {
|
|
return root.Date.now();
|
|
};
|
|
|
|
/**
|
|
* Creates a debounced function that delays invoking `func` until after `wait`
|
|
* milliseconds have elapsed since the last time the debounced function was
|
|
* invoked. The debounced function comes with a `cancel` method to cancel
|
|
* delayed `func` invocations and a `flush` method to immediately invoke them.
|
|
* Provide `options` to indicate whether `func` should be invoked on the
|
|
* leading and/or trailing edge of the `wait` timeout. The `func` is invoked
|
|
* with the last arguments provided to the debounced function. Subsequent
|
|
* calls to the debounced function return the result of the last `func`
|
|
* invocation.
|
|
*
|
|
* **Note:** If `leading` and `trailing` options are `true`, `func` is
|
|
* invoked on the trailing edge of the timeout only if the debounced function
|
|
* is invoked more than once during the `wait` timeout.
|
|
*
|
|
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
|
|
* until to the next tick, similar to `setTimeout` with a timeout of `0`.
|
|
*
|
|
* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
|
|
* for details over the differences between `_.debounce` and `_.throttle`.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 0.1.0
|
|
* @category Function
|
|
* @param {Function} func The function to debounce.
|
|
* @param {number} [wait=0] The number of milliseconds to delay.
|
|
* @param {Object} [options={}] The options object.
|
|
* @param {boolean} [options.leading=false]
|
|
* Specify invoking on the leading edge of the timeout.
|
|
* @param {number} [options.maxWait]
|
|
* The maximum time `func` is allowed to be delayed before it's invoked.
|
|
* @param {boolean} [options.trailing=true]
|
|
* Specify invoking on the trailing edge of the timeout.
|
|
* @returns {Function} Returns the new debounced function.
|
|
* @example
|
|
*
|
|
* // Avoid costly calculations while the window size is in flux.
|
|
* jQuery(window).on('resize', _.debounce(calculateLayout, 150));
|
|
*
|
|
* // Invoke `sendMail` when clicked, debouncing subsequent calls.
|
|
* jQuery(element).on('click', _.debounce(sendMail, 300, {
|
|
* 'leading': true,
|
|
* 'trailing': false
|
|
* }));
|
|
*
|
|
* // Ensure `batchLog` is invoked once after 1 second of debounced calls.
|
|
* var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
|
|
* var source = new EventSource('/stream');
|
|
* jQuery(source).on('message', debounced);
|
|
*
|
|
* // Cancel the trailing debounced invocation.
|
|
* jQuery(window).on('popstate', debounced.cancel);
|
|
*/
|
|
function debounce(func, wait, options) {
|
|
var lastArgs,
|
|
lastThis,
|
|
maxWait,
|
|
result,
|
|
timerId,
|
|
lastCallTime,
|
|
lastInvokeTime = 0,
|
|
leading = false,
|
|
maxing = false,
|
|
trailing = true;
|
|
|
|
if (typeof func != 'function') {
|
|
throw new TypeError(FUNC_ERROR_TEXT);
|
|
}
|
|
wait = toNumber(wait) || 0;
|
|
if (isObject(options)) {
|
|
leading = !!options.leading;
|
|
maxing = 'maxWait' in options;
|
|
maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
|
|
trailing = 'trailing' in options ? !!options.trailing : trailing;
|
|
}
|
|
|
|
function invokeFunc(time) {
|
|
var args = lastArgs,
|
|
thisArg = lastThis;
|
|
|
|
lastArgs = lastThis = undefined;
|
|
lastInvokeTime = time;
|
|
result = func.apply(thisArg, args);
|
|
return result;
|
|
}
|
|
|
|
function leadingEdge(time) {
|
|
// Reset any `maxWait` timer.
|
|
lastInvokeTime = time;
|
|
// Start the timer for the trailing edge.
|
|
timerId = setTimeout(timerExpired, wait);
|
|
// Invoke the leading edge.
|
|
return leading ? invokeFunc(time) : result;
|
|
}
|
|
|
|
function remainingWait(time) {
|
|
var timeSinceLastCall = time - lastCallTime,
|
|
timeSinceLastInvoke = time - lastInvokeTime,
|
|
result = wait - timeSinceLastCall;
|
|
|
|
return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
|
|
}
|
|
|
|
function shouldInvoke(time) {
|
|
var timeSinceLastCall = time - lastCallTime,
|
|
timeSinceLastInvoke = time - lastInvokeTime;
|
|
|
|
// Either this is the first call, activity has stopped and we're at the
|
|
// trailing edge, the system time has gone backwards and we're treating
|
|
// it as the trailing edge, or we've hit the `maxWait` limit.
|
|
return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
|
|
(timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
|
|
}
|
|
|
|
function timerExpired() {
|
|
var time = now();
|
|
if (shouldInvoke(time)) {
|
|
return trailingEdge(time);
|
|
}
|
|
// Restart the timer.
|
|
timerId = setTimeout(timerExpired, remainingWait(time));
|
|
}
|
|
|
|
function trailingEdge(time) {
|
|
timerId = undefined;
|
|
|
|
// Only invoke if we have `lastArgs` which means `func` has been
|
|
// debounced at least once.
|
|
if (trailing && lastArgs) {
|
|
return invokeFunc(time);
|
|
}
|
|
lastArgs = lastThis = undefined;
|
|
return result;
|
|
}
|
|
|
|
function cancel() {
|
|
if (timerId !== undefined) {
|
|
clearTimeout(timerId);
|
|
}
|
|
lastInvokeTime = 0;
|
|
lastArgs = lastCallTime = lastThis = timerId = undefined;
|
|
}
|
|
|
|
function flush() {
|
|
return timerId === undefined ? result : trailingEdge(now());
|
|
}
|
|
|
|
function debounced() {
|
|
var time = now(),
|
|
isInvoking = shouldInvoke(time);
|
|
|
|
lastArgs = arguments;
|
|
lastThis = this;
|
|
lastCallTime = time;
|
|
|
|
if (isInvoking) {
|
|
if (timerId === undefined) {
|
|
return leadingEdge(lastCallTime);
|
|
}
|
|
if (maxing) {
|
|
// Handle invocations in a tight loop.
|
|
timerId = setTimeout(timerExpired, wait);
|
|
return invokeFunc(lastCallTime);
|
|
}
|
|
}
|
|
if (timerId === undefined) {
|
|
timerId = setTimeout(timerExpired, wait);
|
|
}
|
|
return result;
|
|
}
|
|
debounced.cancel = cancel;
|
|
debounced.flush = flush;
|
|
return debounced;
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is the
|
|
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
|
|
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 0.1.0
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObject({});
|
|
* // => true
|
|
*
|
|
* _.isObject([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObject(_.noop);
|
|
* // => true
|
|
*
|
|
* _.isObject(null);
|
|
* // => false
|
|
*/
|
|
function isObject(value) {
|
|
var type = typeof value;
|
|
return !!value && (type == 'object' || type == 'function');
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is object-like. A value is object-like if it's not `null`
|
|
* and has a `typeof` result of "object".
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
|
|
* @example
|
|
*
|
|
* _.isObjectLike({});
|
|
* // => true
|
|
*
|
|
* _.isObjectLike([1, 2, 3]);
|
|
* // => true
|
|
*
|
|
* _.isObjectLike(_.noop);
|
|
* // => false
|
|
*
|
|
* _.isObjectLike(null);
|
|
* // => false
|
|
*/
|
|
function isObjectLike(value) {
|
|
return !!value && typeof value == 'object';
|
|
}
|
|
|
|
/**
|
|
* Checks if `value` is classified as a `Symbol` primitive or object.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to check.
|
|
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
|
|
* @example
|
|
*
|
|
* _.isSymbol(Symbol.iterator);
|
|
* // => true
|
|
*
|
|
* _.isSymbol('abc');
|
|
* // => false
|
|
*/
|
|
function isSymbol(value) {
|
|
return typeof value == 'symbol' ||
|
|
(isObjectLike(value) && objectToString.call(value) == symbolTag);
|
|
}
|
|
|
|
/**
|
|
* Converts `value` to a number.
|
|
*
|
|
* @static
|
|
* @memberOf _
|
|
* @since 4.0.0
|
|
* @category Lang
|
|
* @param {*} value The value to process.
|
|
* @returns {number} Returns the number.
|
|
* @example
|
|
*
|
|
* _.toNumber(3.2);
|
|
* // => 3.2
|
|
*
|
|
* _.toNumber(Number.MIN_VALUE);
|
|
* // => 5e-324
|
|
*
|
|
* _.toNumber(Infinity);
|
|
* // => Infinity
|
|
*
|
|
* _.toNumber('3.2');
|
|
* // => 3.2
|
|
*/
|
|
function toNumber(value) {
|
|
if (typeof value == 'number') {
|
|
return value;
|
|
}
|
|
if (isSymbol(value)) {
|
|
return NAN;
|
|
}
|
|
if (isObject(value)) {
|
|
var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
|
|
value = isObject(other) ? (other + '') : other;
|
|
}
|
|
if (typeof value != 'string') {
|
|
return value === 0 ? value : +value;
|
|
}
|
|
value = value.replace(reTrim, '');
|
|
var isBinary = reIsBinary.test(value);
|
|
return (isBinary || reIsOctal.test(value))
|
|
? freeParseInt(value.slice(2), isBinary ? 2 : 8)
|
|
: (reIsBadHex.test(value) ? NAN : +value);
|
|
}
|
|
|
|
module.exports = debounce;
|
|
|
|
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _common = require("./cmi/common");
|
|
|
|
var _exceptions = require("./exceptions");
|
|
|
|
var _error_codes2 = _interopRequireDefault(require("./constants/error_codes"));
|
|
|
|
var _api_constants = _interopRequireDefault(require("./constants/api_constants"));
|
|
|
|
var _utilities = require("./utilities");
|
|
|
|
var _lodash = _interopRequireDefault(require("lodash.debounce"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
|
|
|
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
|
|
|
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
|
|
|
|
var global_constants = _api_constants["default"].global;
|
|
var scorm12_error_codes = _error_codes2["default"].scorm12;
|
|
/**
|
|
* Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered
|
|
* abstract, and never initialized on it's own.
|
|
*/
|
|
|
|
var _timeout = /*#__PURE__*/new WeakMap();
|
|
|
|
var _error_codes = /*#__PURE__*/new WeakMap();
|
|
|
|
var _settings = /*#__PURE__*/new WeakMap();
|
|
|
|
var BaseAPI = /*#__PURE__*/function () {
|
|
/**
|
|
* Constructor for Base API class. Sets some shared API fields, as well as
|
|
* sets up options for the API.
|
|
* @param {object} error_codes
|
|
* @param {object} settings
|
|
*/
|
|
function BaseAPI(error_codes, settings) {
|
|
_classCallCheck(this, BaseAPI);
|
|
|
|
_timeout.set(this, {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_error_codes.set(this, {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_settings.set(this, {
|
|
writable: true,
|
|
value: {
|
|
autocommit: false,
|
|
autocommitSeconds: 10,
|
|
asyncCommit: false,
|
|
sendBeaconCommit: false,
|
|
lmsCommitUrl: false,
|
|
dataCommitFormat: 'json',
|
|
// valid formats are 'json' or 'flattened', 'params'
|
|
commitRequestDataType: 'application/json;charset=UTF-8',
|
|
autoProgress: false,
|
|
logLevel: global_constants.LOG_LEVEL_ERROR,
|
|
selfReportSessionTime: false,
|
|
alwaysSendTotalTime: false,
|
|
strict_errors: true,
|
|
xhrHeaders: {},
|
|
xhrWithCredentials: false,
|
|
responseHandler: function responseHandler(xhr) {
|
|
var result;
|
|
|
|
if (typeof xhr !== 'undefined') {
|
|
result = JSON.parse(xhr.responseText);
|
|
|
|
if (result === null || !{}.hasOwnProperty.call(result, 'result')) {
|
|
result = {};
|
|
|
|
if (xhr.status === 200) {
|
|
result.result = global_constants.SCORM_TRUE;
|
|
result.errorCode = 0;
|
|
} else {
|
|
result.result = global_constants.SCORM_FALSE;
|
|
result.errorCode = 101;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
});
|
|
|
|
_defineProperty(this, "cmi", void 0);
|
|
|
|
_defineProperty(this, "startingData", void 0);
|
|
|
|
if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) {
|
|
throw new TypeError('Cannot construct BaseAPI instances directly');
|
|
}
|
|
|
|
this.currentState = global_constants.STATE_NOT_INITIALIZED;
|
|
this.lastErrorCode = 0;
|
|
this.listenerArray = [];
|
|
|
|
_classPrivateFieldSet(this, _timeout, null);
|
|
|
|
_classPrivateFieldSet(this, _error_codes, error_codes);
|
|
|
|
this.settings = settings;
|
|
this.apiLogLevel = this.settings.logLevel;
|
|
this.selfReportSessionTime = this.settings.selfReportSessionTime;
|
|
}
|
|
/**
|
|
* Initialize the API
|
|
* @param {string} callbackName
|
|
* @param {string} initializeMessage
|
|
* @param {string} terminationMessage
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
_createClass(BaseAPI, [{
|
|
key: "initialize",
|
|
value: function initialize(callbackName, initializeMessage, terminationMessage) {
|
|
var returnValue = global_constants.SCORM_FALSE;
|
|
|
|
if (this.isInitialized()) {
|
|
this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage);
|
|
} else if (this.isTerminated()) {
|
|
this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage);
|
|
} else {
|
|
if (this.selfReportSessionTime) {
|
|
this.cmi.setStartTime();
|
|
}
|
|
|
|
this.currentState = global_constants.STATE_INITIALIZED;
|
|
this.lastErrorCode = 0;
|
|
returnValue = global_constants.SCORM_TRUE;
|
|
this.processListeners(callbackName);
|
|
}
|
|
|
|
this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
this.clearSCORMError(returnValue);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Getter for #error_codes
|
|
* @return {object}
|
|
*/
|
|
|
|
}, {
|
|
key: "error_codes",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _error_codes);
|
|
}
|
|
/**
|
|
* Getter for #settings
|
|
* @return {object}
|
|
*/
|
|
|
|
}, {
|
|
key: "settings",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _settings);
|
|
}
|
|
/**
|
|
* Setter for #settings
|
|
* @param {object} settings
|
|
*/
|
|
,
|
|
set: function set(settings) {
|
|
_classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings));
|
|
}
|
|
/**
|
|
* Terminates the current run of the API
|
|
* @param {string} callbackName
|
|
* @param {boolean} checkTerminated
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "terminate",
|
|
value: function terminate(callbackName, checkTerminated) {
|
|
var returnValue = global_constants.SCORM_FALSE;
|
|
|
|
if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) {
|
|
this.currentState = global_constants.STATE_TERMINATED;
|
|
var result = this.storeData(true);
|
|
|
|
if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) {
|
|
this.throwSCORMError(result.errorCode);
|
|
}
|
|
|
|
returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE;
|
|
if (checkTerminated) this.lastErrorCode = 0;
|
|
returnValue = global_constants.SCORM_TRUE;
|
|
this.processListeners(callbackName);
|
|
}
|
|
|
|
this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
this.clearSCORMError(returnValue);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Get the value of the CMIElement.
|
|
*
|
|
* @param {string} callbackName
|
|
* @param {boolean} checkTerminated
|
|
* @param {string} CMIElement
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "getValue",
|
|
value: function getValue(callbackName, checkTerminated, CMIElement) {
|
|
var returnValue;
|
|
|
|
if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) {
|
|
if (checkTerminated) this.lastErrorCode = 0;
|
|
|
|
try {
|
|
returnValue = this.getCMIValue(CMIElement);
|
|
} catch (e) {
|
|
if (e instanceof _exceptions.ValidationError) {
|
|
this.lastErrorCode = e.errorCode;
|
|
returnValue = global_constants.SCORM_FALSE;
|
|
} else {
|
|
if (e.message) {
|
|
console.error(e.message);
|
|
} else {
|
|
console.error(e);
|
|
}
|
|
|
|
this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL);
|
|
}
|
|
}
|
|
|
|
this.processListeners(callbackName, CMIElement);
|
|
}
|
|
|
|
this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
this.clearSCORMError(returnValue);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Sets the value of the CMIElement.
|
|
*
|
|
* @param {string} callbackName
|
|
* @param {string} commitCallback
|
|
* @param {boolean} checkTerminated
|
|
* @param {string} CMIElement
|
|
* @param {*} value
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "setValue",
|
|
value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) {
|
|
if (value !== undefined) {
|
|
value = String(value);
|
|
}
|
|
|
|
var returnValue = global_constants.SCORM_FALSE;
|
|
|
|
if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) {
|
|
if (checkTerminated) this.lastErrorCode = 0;
|
|
|
|
try {
|
|
returnValue = this.setCMIValue(CMIElement, value);
|
|
} catch (e) {
|
|
if (e instanceof _exceptions.ValidationError) {
|
|
this.lastErrorCode = e.errorCode;
|
|
returnValue = global_constants.SCORM_FALSE;
|
|
} else {
|
|
if (e.message) {
|
|
console.error(e.message);
|
|
} else {
|
|
console.error(e);
|
|
}
|
|
|
|
this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL);
|
|
}
|
|
}
|
|
|
|
this.processListeners(callbackName, CMIElement, value);
|
|
}
|
|
|
|
if (returnValue === undefined) {
|
|
returnValue = global_constants.SCORM_FALSE;
|
|
} // If we didn't have any errors while setting the data, go ahead and
|
|
// schedule a commit, if autocommit is turned on
|
|
|
|
|
|
if (String(this.lastErrorCode) === '0') {
|
|
if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) {
|
|
this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);
|
|
}
|
|
}
|
|
|
|
this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
this.clearSCORMError(returnValue);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Orders LMS to store all content parameters
|
|
* @param {string} callbackName
|
|
* @param {boolean} checkTerminated
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "commit",
|
|
value: function commit(callbackName, checkTerminated) {
|
|
this.clearScheduledCommit();
|
|
var returnValue = global_constants.SCORM_FALSE;
|
|
|
|
if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) {
|
|
var result = this.storeData(false);
|
|
|
|
if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) {
|
|
this.throwSCORMError(result.errorCode);
|
|
}
|
|
|
|
returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE;
|
|
this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG);
|
|
if (checkTerminated) this.lastErrorCode = 0;
|
|
this.processListeners(callbackName);
|
|
}
|
|
|
|
this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
this.clearSCORMError(returnValue);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Returns last error code
|
|
* @param {string} callbackName
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "getLastError",
|
|
value: function getLastError(callbackName) {
|
|
var returnValue = String(this.lastErrorCode);
|
|
this.processListeners(callbackName);
|
|
this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Returns the errorNumber error description
|
|
*
|
|
* @param {string} callbackName
|
|
* @param {(string|number)} CMIErrorCode
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "getErrorString",
|
|
value: function getErrorString(callbackName, CMIErrorCode) {
|
|
var returnValue = '';
|
|
|
|
if (CMIErrorCode !== null && CMIErrorCode !== '') {
|
|
returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);
|
|
this.processListeners(callbackName);
|
|
}
|
|
|
|
this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Returns a comprehensive description of the errorNumber error.
|
|
*
|
|
* @param {string} callbackName
|
|
* @param {(string|number)} CMIErrorCode
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "getDiagnostic",
|
|
value: function getDiagnostic(callbackName, CMIErrorCode) {
|
|
var returnValue = '';
|
|
|
|
if (CMIErrorCode !== null && CMIErrorCode !== '') {
|
|
returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);
|
|
this.processListeners(callbackName);
|
|
}
|
|
|
|
this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO);
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Checks the LMS state and ensures it has been initialized.
|
|
*
|
|
* @param {boolean} checkTerminated
|
|
* @param {number} beforeInitError
|
|
* @param {number} afterTermError
|
|
* @return {boolean}
|
|
*/
|
|
|
|
}, {
|
|
key: "checkState",
|
|
value: function checkState(checkTerminated, beforeInitError, afterTermError) {
|
|
if (this.isNotInitialized()) {
|
|
this.throwSCORMError(beforeInitError);
|
|
return false;
|
|
} else if (checkTerminated && this.isTerminated()) {
|
|
this.throwSCORMError(afterTermError);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
/**
|
|
* Logging for all SCORM actions
|
|
*
|
|
* @param {string} functionName
|
|
* @param {string} CMIElement
|
|
* @param {string} logMessage
|
|
* @param {number}messageLevel
|
|
*/
|
|
|
|
}, {
|
|
key: "apiLog",
|
|
value: function apiLog(functionName, CMIElement, logMessage, messageLevel) {
|
|
logMessage = this.formatMessage(functionName, CMIElement, logMessage);
|
|
|
|
if (messageLevel >= this.apiLogLevel) {
|
|
switch (messageLevel) {
|
|
case global_constants.LOG_LEVEL_ERROR:
|
|
console.error(logMessage);
|
|
break;
|
|
|
|
case global_constants.LOG_LEVEL_WARNING:
|
|
console.warn(logMessage);
|
|
break;
|
|
|
|
case global_constants.LOG_LEVEL_INFO:
|
|
console.info(logMessage);
|
|
break;
|
|
|
|
case global_constants.LOG_LEVEL_DEBUG:
|
|
if (console.debug) {
|
|
console.debug(logMessage);
|
|
} else {
|
|
console.log(logMessage);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Formats the SCORM messages for easy reading
|
|
*
|
|
* @param {string} functionName
|
|
* @param {string} CMIElement
|
|
* @param {string} message
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "formatMessage",
|
|
value: function formatMessage(functionName, CMIElement, message) {
|
|
var baseLength = 20;
|
|
var messageString = '';
|
|
messageString += functionName;
|
|
var fillChars = baseLength - messageString.length;
|
|
|
|
for (var i = 0; i < fillChars; i++) {
|
|
messageString += ' ';
|
|
}
|
|
|
|
messageString += ': ';
|
|
|
|
if (CMIElement) {
|
|
var CMIElementBaseLength = 70;
|
|
messageString += CMIElement;
|
|
fillChars = CMIElementBaseLength - messageString.length;
|
|
|
|
for (var j = 0; j < fillChars; j++) {
|
|
messageString += ' ';
|
|
}
|
|
}
|
|
|
|
if (message) {
|
|
messageString += message;
|
|
}
|
|
|
|
return messageString;
|
|
}
|
|
/**
|
|
* Checks to see if {str} contains {tester}
|
|
*
|
|
* @param {string} str String to check against
|
|
* @param {string} tester String to check for
|
|
* @return {boolean}
|
|
*/
|
|
|
|
}, {
|
|
key: "stringMatches",
|
|
value: function stringMatches(str, tester) {
|
|
return str && tester && str.match(tester);
|
|
}
|
|
/**
|
|
* Check to see if the specific object has the given property
|
|
* @param {*} refObject
|
|
* @param {string} attribute
|
|
* @return {boolean}
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: "_checkObjectHasProperty",
|
|
value: function _checkObjectHasProperty(refObject, attribute) {
|
|
return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject;
|
|
}
|
|
/**
|
|
* Returns the message that corresponds to errorNumber
|
|
* APIs that inherit BaseAPI should override this function
|
|
*
|
|
* @param {(string|number)} _errorNumber
|
|
* @param {boolean} _detail
|
|
* @return {string}
|
|
* @abstract
|
|
*/
|
|
|
|
}, {
|
|
key: "getLmsErrorMessageDetails",
|
|
value: function getLmsErrorMessageDetails(_errorNumber, _detail) {
|
|
throw new Error('The getLmsErrorMessageDetails method has not been implemented');
|
|
}
|
|
/**
|
|
* Gets the value for the specific element.
|
|
* APIs that inherit BaseAPI should override this function
|
|
*
|
|
* @param {string} _CMIElement
|
|
* @return {string}
|
|
* @abstract
|
|
*/
|
|
|
|
}, {
|
|
key: "getCMIValue",
|
|
value: function getCMIValue(_CMIElement) {
|
|
throw new Error('The getCMIValue method has not been implemented');
|
|
}
|
|
/**
|
|
* Sets the value for the specific element.
|
|
* APIs that inherit BaseAPI should override this function
|
|
*
|
|
* @param {string} _CMIElement
|
|
* @param {any} _value
|
|
* @return {string}
|
|
* @abstract
|
|
*/
|
|
|
|
}, {
|
|
key: "setCMIValue",
|
|
value: function setCMIValue(_CMIElement, _value) {
|
|
throw new Error('The setCMIValue method has not been implemented');
|
|
}
|
|
/**
|
|
* Shared API method to set a valid for a given element.
|
|
*
|
|
* @param {string} methodName
|
|
* @param {boolean} scorm2004
|
|
* @param {string} CMIElement
|
|
* @param {*} value
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "_commonSetCMIValue",
|
|
value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) {
|
|
if (!CMIElement || CMIElement === '') {
|
|
return global_constants.SCORM_FALSE;
|
|
}
|
|
|
|
var structure = CMIElement.split('.');
|
|
var refObject = this;
|
|
var returnValue = global_constants.SCORM_FALSE;
|
|
var foundFirstIndex = false;
|
|
var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element.");
|
|
var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL;
|
|
|
|
for (var i = 0; i < structure.length; i++) {
|
|
var attribute = structure[i];
|
|
|
|
if (i === structure.length - 1) {
|
|
if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') {
|
|
this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT);
|
|
} else if (!this._checkObjectHasProperty(refObject, attribute)) {
|
|
this.throwSCORMError(invalidErrorCode, invalidErrorMessage);
|
|
} else {
|
|
if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) {
|
|
this.validateCorrectResponse(CMIElement, value);
|
|
}
|
|
|
|
if (!scorm2004 || this.lastErrorCode === 0) {
|
|
refObject[attribute] = value;
|
|
returnValue = global_constants.SCORM_TRUE;
|
|
}
|
|
}
|
|
} else {
|
|
refObject = refObject[attribute];
|
|
|
|
if (!refObject) {
|
|
this.throwSCORMError(invalidErrorCode, invalidErrorMessage);
|
|
break;
|
|
}
|
|
|
|
if (refObject instanceof _common.CMIArray) {
|
|
var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array
|
|
|
|
if (!isNaN(index)) {
|
|
var item = refObject.childArray[index];
|
|
|
|
if (item) {
|
|
refObject = item;
|
|
foundFirstIndex = true;
|
|
} else {
|
|
var newChild = this.getChildElement(CMIElement, value, foundFirstIndex);
|
|
foundFirstIndex = true;
|
|
|
|
if (!newChild) {
|
|
this.throwSCORMError(invalidErrorCode, invalidErrorMessage);
|
|
} else {
|
|
if (refObject.initialized) newChild.initialize();
|
|
refObject.childArray.push(newChild);
|
|
refObject = newChild;
|
|
}
|
|
} // Have to update i value to skip the array position
|
|
|
|
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (returnValue === global_constants.SCORM_FALSE) {
|
|
this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING);
|
|
}
|
|
|
|
return returnValue;
|
|
}
|
|
/**
|
|
* Abstract method for validating that a response is correct.
|
|
*
|
|
* @param {string} _CMIElement
|
|
* @param {*} _value
|
|
*/
|
|
|
|
}, {
|
|
key: "validateCorrectResponse",
|
|
value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method
|
|
}
|
|
/**
|
|
* Gets or builds a new child element to add to the array.
|
|
* APIs that inherit BaseAPI should override this method.
|
|
*
|
|
* @param {string} _CMIElement - unused
|
|
* @param {*} _value - unused
|
|
* @param {boolean} _foundFirstIndex - unused
|
|
* @return {*}
|
|
* @abstract
|
|
*/
|
|
|
|
}, {
|
|
key: "getChildElement",
|
|
value: function getChildElement(_CMIElement, _value, _foundFirstIndex) {
|
|
throw new Error('The getChildElement method has not been implemented');
|
|
}
|
|
/**
|
|
* Gets a value from the CMI Object
|
|
*
|
|
* @param {string} methodName
|
|
* @param {boolean} scorm2004
|
|
* @param {string} CMIElement
|
|
* @return {*}
|
|
*/
|
|
|
|
}, {
|
|
key: "_commonGetCMIValue",
|
|
value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) {
|
|
if (!CMIElement || CMIElement === '') {
|
|
return '';
|
|
}
|
|
|
|
var structure = CMIElement.split('.');
|
|
var refObject = this;
|
|
var attribute = null;
|
|
var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized.");
|
|
var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element.");
|
|
var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL;
|
|
|
|
for (var i = 0; i < structure.length; i++) {
|
|
attribute = structure[i];
|
|
|
|
if (!scorm2004) {
|
|
if (i === structure.length - 1) {
|
|
if (!this._checkObjectHasProperty(refObject, attribute)) {
|
|
this.throwSCORMError(invalidErrorCode, invalidErrorMessage);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') {
|
|
var target = String(attribute).substr(8, String(attribute).length - 9);
|
|
return refObject._isTargetValid(target);
|
|
} else if (!this._checkObjectHasProperty(refObject, attribute)) {
|
|
this.throwSCORMError(invalidErrorCode, invalidErrorMessage);
|
|
return;
|
|
}
|
|
}
|
|
|
|
refObject = refObject[attribute];
|
|
|
|
if (refObject === undefined) {
|
|
this.throwSCORMError(invalidErrorCode, invalidErrorMessage);
|
|
break;
|
|
}
|
|
|
|
if (refObject instanceof _common.CMIArray) {
|
|
var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array
|
|
|
|
if (!isNaN(index)) {
|
|
var item = refObject.childArray[index];
|
|
|
|
if (item) {
|
|
refObject = item;
|
|
} else {
|
|
this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage);
|
|
break;
|
|
} // Have to update i value to skip the array position
|
|
|
|
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (refObject === null || refObject === undefined) {
|
|
if (!scorm2004) {
|
|
if (attribute === '_children') {
|
|
this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);
|
|
} else if (attribute === '_count') {
|
|
this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);
|
|
}
|
|
}
|
|
} else {
|
|
return refObject;
|
|
}
|
|
}
|
|
/**
|
|
* Returns true if the API's current state is STATE_INITIALIZED
|
|
*
|
|
* @return {boolean}
|
|
*/
|
|
|
|
}, {
|
|
key: "isInitialized",
|
|
value: function isInitialized() {
|
|
return this.currentState === global_constants.STATE_INITIALIZED;
|
|
}
|
|
/**
|
|
* Returns true if the API's current state is STATE_NOT_INITIALIZED
|
|
*
|
|
* @return {boolean}
|
|
*/
|
|
|
|
}, {
|
|
key: "isNotInitialized",
|
|
value: function isNotInitialized() {
|
|
return this.currentState === global_constants.STATE_NOT_INITIALIZED;
|
|
}
|
|
/**
|
|
* Returns true if the API's current state is STATE_TERMINATED
|
|
*
|
|
* @return {boolean}
|
|
*/
|
|
|
|
}, {
|
|
key: "isTerminated",
|
|
value: function isTerminated() {
|
|
return this.currentState === global_constants.STATE_TERMINATED;
|
|
}
|
|
/**
|
|
* Provides a mechanism for attaching to a specific SCORM event
|
|
*
|
|
* @param {string} listenerName
|
|
* @param {function} callback
|
|
*/
|
|
|
|
}, {
|
|
key: "on",
|
|
value: function on(listenerName, callback) {
|
|
if (!callback) return;
|
|
var listenerFunctions = listenerName.split(' ');
|
|
|
|
for (var i = 0; i < listenerFunctions.length; i++) {
|
|
var listenerSplit = listenerFunctions[i].split('.');
|
|
if (listenerSplit.length === 0) return;
|
|
var functionName = listenerSplit[0];
|
|
var CMIElement = null;
|
|
|
|
if (listenerSplit.length > 1) {
|
|
CMIElement = listenerName.replace(functionName + '.', '');
|
|
}
|
|
|
|
this.listenerArray.push({
|
|
functionName: functionName,
|
|
CMIElement: CMIElement,
|
|
callback: callback
|
|
});
|
|
this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO);
|
|
}
|
|
}
|
|
/**
|
|
* Provides a mechanism for detaching a specific SCORM event listener
|
|
*
|
|
* @param {string} listenerName
|
|
* @param {function} callback
|
|
*/
|
|
|
|
}, {
|
|
key: "off",
|
|
value: function off(listenerName, callback) {
|
|
var _this = this;
|
|
|
|
if (!callback) return;
|
|
var listenerFunctions = listenerName.split(' ');
|
|
|
|
var _loop = function _loop(i) {
|
|
var listenerSplit = listenerFunctions[i].split('.');
|
|
if (listenerSplit.length === 0) return {
|
|
v: void 0
|
|
};
|
|
var functionName = listenerSplit[0];
|
|
var CMIElement = null;
|
|
|
|
if (listenerSplit.length > 1) {
|
|
CMIElement = listenerName.replace(functionName + '.', '');
|
|
}
|
|
|
|
var removeIndex = _this.listenerArray.findIndex(function (obj) {
|
|
return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback;
|
|
});
|
|
|
|
if (removeIndex !== -1) {
|
|
_this.listenerArray.splice(removeIndex, 1);
|
|
|
|
_this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO);
|
|
}
|
|
};
|
|
|
|
for (var i = 0; i < listenerFunctions.length; i++) {
|
|
var _ret = _loop(i);
|
|
|
|
if (_typeof(_ret) === "object") return _ret.v;
|
|
}
|
|
}
|
|
/**
|
|
* Provides a mechanism for clearing all listeners from a specific SCORM event
|
|
*
|
|
* @param {string} listenerName
|
|
*/
|
|
|
|
}, {
|
|
key: "clear",
|
|
value: function clear(listenerName) {
|
|
var _this2 = this;
|
|
|
|
var listenerFunctions = listenerName.split(' ');
|
|
|
|
var _loop2 = function _loop2(i) {
|
|
var listenerSplit = listenerFunctions[i].split('.');
|
|
if (listenerSplit.length === 0) return {
|
|
v: void 0
|
|
};
|
|
var functionName = listenerSplit[0];
|
|
var CMIElement = null;
|
|
|
|
if (listenerSplit.length > 1) {
|
|
CMIElement = listenerName.replace(functionName + '.', '');
|
|
}
|
|
|
|
_this2.listenerArray = _this2.listenerArray.filter(function (obj) {
|
|
return obj.functionName !== functionName && obj.CMIElement !== CMIElement;
|
|
});
|
|
};
|
|
|
|
for (var i = 0; i < listenerFunctions.length; i++) {
|
|
var _ret2 = _loop2(i);
|
|
|
|
if (_typeof(_ret2) === "object") return _ret2.v;
|
|
}
|
|
}
|
|
/**
|
|
* Processes any 'on' listeners that have been created
|
|
*
|
|
* @param {string} functionName
|
|
* @param {string} CMIElement
|
|
* @param {*} value
|
|
*/
|
|
|
|
}, {
|
|
key: "processListeners",
|
|
value: function processListeners(functionName, CMIElement, value) {
|
|
this.apiLog(functionName, CMIElement, value);
|
|
|
|
for (var i = 0; i < this.listenerArray.length; i++) {
|
|
var listener = this.listenerArray[i];
|
|
var functionsMatch = listener.functionName === functionName;
|
|
var listenerHasCMIElement = !!listener.CMIElement;
|
|
var CMIElementsMatch = false;
|
|
|
|
if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') {
|
|
CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0;
|
|
} else {
|
|
CMIElementsMatch = listener.CMIElement === CMIElement;
|
|
}
|
|
|
|
if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {
|
|
listener.callback(CMIElement, value);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Throws a SCORM error
|
|
*
|
|
* @param {number} errorNumber
|
|
* @param {string} message
|
|
*/
|
|
|
|
}, {
|
|
key: "throwSCORMError",
|
|
value: function throwSCORMError(errorNumber, message) {
|
|
if (!message) {
|
|
message = this.getLmsErrorMessageDetails(errorNumber);
|
|
}
|
|
|
|
this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR);
|
|
this.lastErrorCode = String(errorNumber);
|
|
}
|
|
/**
|
|
* Clears the last SCORM error code on success.
|
|
*
|
|
* @param {string} success
|
|
*/
|
|
|
|
}, {
|
|
key: "clearSCORMError",
|
|
value: function clearSCORMError(success) {
|
|
if (success !== undefined && success !== global_constants.SCORM_FALSE) {
|
|
this.lastErrorCode = 0;
|
|
}
|
|
}
|
|
/**
|
|
* Attempts to store the data to the LMS, logs data if no LMS configured
|
|
* APIs that inherit BaseAPI should override this function
|
|
*
|
|
* @param {boolean} _calculateTotalTime
|
|
* @return {string}
|
|
* @abstract
|
|
*/
|
|
|
|
}, {
|
|
key: "storeData",
|
|
value: function storeData(_calculateTotalTime) {
|
|
throw new Error('The storeData method has not been implemented');
|
|
}
|
|
/**
|
|
* Load the CMI from a flattened JSON object
|
|
* @param {object} json
|
|
* @param {string} CMIElement
|
|
*/
|
|
|
|
}, {
|
|
key: "loadFromFlattenedJSON",
|
|
value: function loadFromFlattenedJSON(json, CMIElement) {
|
|
var _this3 = this;
|
|
|
|
if (!this.isNotInitialized()) {
|
|
console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.');
|
|
return;
|
|
}
|
|
/**
|
|
* Test match pattern.
|
|
*
|
|
* @param {string} a
|
|
* @param {string} c
|
|
* @param {RegExp} a_pattern
|
|
* @return {number}
|
|
*/
|
|
|
|
|
|
function testPattern(a, c, a_pattern) {
|
|
var a_match = a.match(a_pattern);
|
|
var c_match;
|
|
|
|
if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {
|
|
var a_num = Number(a_match[2]);
|
|
var c_num = Number(c_match[2]);
|
|
|
|
if (a_num === c_num) {
|
|
if (a_match[3] === 'id') {
|
|
return -1;
|
|
} else if (a_match[3] === 'type') {
|
|
if (c_match[3] === 'id') {
|
|
return 1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return a_num - c_num;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/;
|
|
var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/;
|
|
var result = Object.keys(json).map(function (key) {
|
|
return [String(key), json[key]];
|
|
}); // CMI interactions need to have id and type loaded before any other fields
|
|
|
|
result.sort(function (_ref, _ref2) {
|
|
var _ref3 = _slicedToArray(_ref, 2),
|
|
a = _ref3[0],
|
|
b = _ref3[1];
|
|
|
|
var _ref4 = _slicedToArray(_ref2, 2),
|
|
c = _ref4[0],
|
|
d = _ref4[1];
|
|
|
|
var test;
|
|
|
|
if ((test = testPattern(a, c, int_pattern)) !== null) {
|
|
return test;
|
|
}
|
|
|
|
if ((test = testPattern(a, c, obj_pattern)) !== null) {
|
|
return test;
|
|
}
|
|
|
|
if (a < c) {
|
|
return -1;
|
|
}
|
|
|
|
if (a > c) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
});
|
|
var obj;
|
|
result.forEach(function (element) {
|
|
obj = {};
|
|
obj[element[0]] = element[1];
|
|
|
|
_this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement);
|
|
});
|
|
}
|
|
/**
|
|
* Loads CMI data from a JSON object.
|
|
*
|
|
* @param {object} json
|
|
* @param {string} CMIElement
|
|
*/
|
|
|
|
}, {
|
|
key: "loadFromJSON",
|
|
value: function loadFromJSON(json, CMIElement) {
|
|
if (!this.isNotInitialized()) {
|
|
console.error('loadFromJSON can only be called before the call to lmsInitialize.');
|
|
return;
|
|
}
|
|
|
|
CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';
|
|
this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each?
|
|
|
|
for (var key in json) {
|
|
if ({}.hasOwnProperty.call(json, key) && json[key]) {
|
|
var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;
|
|
var value = json[key];
|
|
|
|
if (value['childArray']) {
|
|
for (var i = 0; i < value['childArray'].length; i++) {
|
|
this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i);
|
|
}
|
|
} else if (value.constructor === Object) {
|
|
this.loadFromJSON(value, currentCMIElement);
|
|
} else {
|
|
this.setCMIValue(currentCMIElement, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Render the CMI object to JSON for sending to an LMS.
|
|
*
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "renderCMIToJSONString",
|
|
value: function renderCMIToJSONString() {
|
|
var cmi = this.cmi; // Do we want/need to return fields that have no set value?
|
|
// return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);
|
|
|
|
return JSON.stringify({
|
|
cmi: cmi
|
|
});
|
|
}
|
|
/**
|
|
* Returns a JS object representing the current cmi
|
|
* @return {object}
|
|
*/
|
|
|
|
}, {
|
|
key: "renderCMIToJSONObject",
|
|
value: function renderCMIToJSONObject() {
|
|
// Do we want/need to return fields that have no set value?
|
|
// return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);
|
|
return JSON.parse(this.renderCMIToJSONString());
|
|
}
|
|
/**
|
|
* Render the cmi object to the proper format for LMS commit
|
|
* APIs that inherit BaseAPI should override this function
|
|
*
|
|
* @param {boolean} _terminateCommit
|
|
* @return {*}
|
|
* @abstract
|
|
*/
|
|
|
|
}, {
|
|
key: "renderCommitCMI",
|
|
value: function renderCommitCMI(_terminateCommit) {
|
|
throw new Error('The storeData method has not been implemented');
|
|
}
|
|
/**
|
|
* Send the request to the LMS
|
|
* @param {string} url
|
|
* @param {object|Array} params
|
|
* @param {boolean} immediate
|
|
* @return {object}
|
|
*/
|
|
|
|
}, {
|
|
key: "processHttpRequest",
|
|
value: function processHttpRequest(url, params) {
|
|
var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
|
var api = this;
|
|
|
|
var process = function process(url, params, settings, error_codes) {
|
|
var genericError = {
|
|
'result': global_constants.SCORM_FALSE,
|
|
'errorCode': error_codes.GENERAL
|
|
};
|
|
var result;
|
|
|
|
if (!settings.sendBeaconCommit) {
|
|
var httpReq = new XMLHttpRequest();
|
|
httpReq.open('POST', url, settings.asyncCommit);
|
|
|
|
if (Object.keys(settings.xhrHeaders).length) {
|
|
Object.keys(settings.xhrHeaders).forEach(function (header) {
|
|
httpReq.setRequestHeader(header, settings.xhrHeaders[header]);
|
|
});
|
|
}
|
|
|
|
httpReq.withCredentials = settings.xhrWithCredentials;
|
|
|
|
if (settings.asyncCommit) {
|
|
httpReq.onload = function (e) {
|
|
if (typeof settings.responseHandler === 'function') {
|
|
result = settings.responseHandler(httpReq);
|
|
} else {
|
|
result = JSON.parse(httpReq.responseText);
|
|
}
|
|
};
|
|
}
|
|
|
|
try {
|
|
if (params instanceof Array) {
|
|
httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
|
|
httpReq.send(params.join('&'));
|
|
} else {
|
|
httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType);
|
|
httpReq.send(JSON.stringify(params));
|
|
}
|
|
|
|
if (!settings.asyncCommit) {
|
|
if (typeof settings.responseHandler === 'function') {
|
|
result = settings.responseHandler(httpReq);
|
|
} else {
|
|
result = JSON.parse(httpReq.responseText);
|
|
}
|
|
} else {
|
|
result = {};
|
|
result.result = global_constants.SCORM_TRUE;
|
|
result.errorCode = 0;
|
|
api.processListeners('CommitSuccess');
|
|
return result;
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
api.processListeners('CommitError');
|
|
return genericError;
|
|
}
|
|
} else {
|
|
try {
|
|
var headers = {
|
|
type: settings.commitRequestDataType
|
|
};
|
|
var blob;
|
|
|
|
if (params instanceof Array) {
|
|
blob = new Blob([params.join('&')], headers);
|
|
} else {
|
|
blob = new Blob([JSON.stringify(params)], headers);
|
|
}
|
|
|
|
result = {};
|
|
|
|
if (navigator.sendBeacon(url, blob)) {
|
|
result.result = global_constants.SCORM_TRUE;
|
|
result.errorCode = 0;
|
|
} else {
|
|
result.result = global_constants.SCORM_FALSE;
|
|
result.errorCode = 101;
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
api.processListeners('CommitError');
|
|
return genericError;
|
|
}
|
|
}
|
|
|
|
if (typeof result === 'undefined') {
|
|
api.processListeners('CommitError');
|
|
return genericError;
|
|
}
|
|
|
|
if (result.result === true || result.result === global_constants.SCORM_TRUE) {
|
|
api.processListeners('CommitSuccess');
|
|
} else {
|
|
api.processListeners('CommitError');
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
if (typeof _lodash["default"] !== 'undefined') {
|
|
var debounced = (0, _lodash["default"])(process, 500);
|
|
debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately
|
|
|
|
if (immediate) {
|
|
debounced.flush();
|
|
}
|
|
|
|
return {
|
|
result: global_constants.SCORM_TRUE,
|
|
errorCode: 0
|
|
};
|
|
} else {
|
|
return process(url, params, this.settings, this.error_codes);
|
|
}
|
|
}
|
|
/**
|
|
* Throws a SCORM error
|
|
*
|
|
* @param {number} when - the number of milliseconds to wait before committing
|
|
* @param {string} callback - the name of the commit event callback
|
|
*/
|
|
|
|
}, {
|
|
key: "scheduleCommit",
|
|
value: function scheduleCommit(when, callback) {
|
|
_classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback));
|
|
|
|
this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG);
|
|
}
|
|
/**
|
|
* Clears and cancels any currently scheduled commits
|
|
*/
|
|
|
|
}, {
|
|
key: "clearScheduledCommit",
|
|
value: function clearScheduledCommit() {
|
|
if (_classPrivateFieldGet(this, _timeout)) {
|
|
_classPrivateFieldGet(this, _timeout).cancel();
|
|
|
|
_classPrivateFieldSet(this, _timeout, null);
|
|
|
|
this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return BaseAPI;
|
|
}();
|
|
/**
|
|
* Private class that wraps a timeout call to the commit() function
|
|
*/
|
|
|
|
|
|
exports["default"] = BaseAPI;
|
|
|
|
var _API = /*#__PURE__*/new WeakMap();
|
|
|
|
var _cancelled = /*#__PURE__*/new WeakMap();
|
|
|
|
var _timeout2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _callback = /*#__PURE__*/new WeakMap();
|
|
|
|
var ScheduledCommit = /*#__PURE__*/function () {
|
|
/**
|
|
* Constructor for ScheduledCommit
|
|
* @param {BaseAPI} API
|
|
* @param {number} when
|
|
* @param {string} callback
|
|
*/
|
|
function ScheduledCommit(API, when, callback) {
|
|
_classCallCheck(this, ScheduledCommit);
|
|
|
|
_API.set(this, {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_cancelled.set(this, {
|
|
writable: true,
|
|
value: false
|
|
});
|
|
|
|
_timeout2.set(this, {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_callback.set(this, {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_classPrivateFieldSet(this, _API, API);
|
|
|
|
_classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when));
|
|
|
|
_classPrivateFieldSet(this, _callback, callback);
|
|
}
|
|
/**
|
|
* Cancel any currently scheduled commit
|
|
*/
|
|
|
|
|
|
_createClass(ScheduledCommit, [{
|
|
key: "cancel",
|
|
value: function cancel() {
|
|
_classPrivateFieldSet(this, _cancelled, true);
|
|
|
|
if (_classPrivateFieldGet(this, _timeout2)) {
|
|
clearTimeout(_classPrivateFieldGet(this, _timeout2));
|
|
}
|
|
}
|
|
/**
|
|
* Wrap the API commit call to check if the call has already been cancelled
|
|
*/
|
|
|
|
}, {
|
|
key: "wrapper",
|
|
value: function wrapper() {
|
|
if (!_classPrivateFieldGet(this, _cancelled)) {
|
|
_classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback));
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return ScheduledCommit;
|
|
}();
|
|
|
|
},{"./cmi/common":4,"./constants/api_constants":6,"./constants/error_codes":7,"./exceptions":11,"./utilities":13,"lodash.debounce":1}],3:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI"));
|
|
|
|
var _scorm2004_cmi = require("./cmi/scorm2004_cmi");
|
|
|
|
var Utilities = _interopRequireWildcard(require("./utilities"));
|
|
|
|
var _api_constants = _interopRequireDefault(require("./constants/api_constants"));
|
|
|
|
var _error_codes = _interopRequireDefault(require("./constants/error_codes"));
|
|
|
|
var _response_constants = _interopRequireDefault(require("./constants/response_constants"));
|
|
|
|
var _language_constants = _interopRequireDefault(require("./constants/language_constants"));
|
|
|
|
var _regex = _interopRequireDefault(require("./constants/regex"));
|
|
|
|
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
|
|
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
var scorm2004_constants = _api_constants["default"].scorm2004;
|
|
var global_constants = _api_constants["default"].global;
|
|
var scorm2004_error_codes = _error_codes["default"].scorm2004;
|
|
var correct_responses = _response_constants["default"].correct;
|
|
var scorm2004_regex = _regex["default"].scorm2004;
|
|
/**
|
|
* API class for SCORM 2004
|
|
*/
|
|
|
|
var _version = /*#__PURE__*/new WeakMap();
|
|
|
|
var Scorm2004API = /*#__PURE__*/function (_BaseAPI) {
|
|
_inherits(Scorm2004API, _BaseAPI);
|
|
|
|
var _super = _createSuper(Scorm2004API);
|
|
|
|
/**
|
|
* Constructor for SCORM 2004 API
|
|
* @param {object} settings
|
|
*/
|
|
function Scorm2004API(settings) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, Scorm2004API);
|
|
|
|
var finalSettings = _objectSpread(_objectSpread({}, {
|
|
mastery_override: false
|
|
}), settings);
|
|
|
|
_this = _super.call(this, scorm2004_error_codes, finalSettings);
|
|
|
|
_version.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_defineProperty(_assertThisInitialized(_this), "checkDuplicatedPattern", function (correct_response, current_index, value) {
|
|
var found = false;
|
|
var count = correct_response._count;
|
|
|
|
for (var i = 0; i < count && !found; i++) {
|
|
if (i !== current_index && correct_response.childArray[i] === value) {
|
|
found = true;
|
|
}
|
|
}
|
|
|
|
return found;
|
|
});
|
|
|
|
_this.cmi = new _scorm2004_cmi.CMI();
|
|
_this.adl = new _scorm2004_cmi.ADL(); // Rename functions to match 2004 Spec and expose to modules
|
|
|
|
_this.Initialize = _this.lmsInitialize;
|
|
_this.Terminate = _this.lmsTerminate;
|
|
_this.GetValue = _this.lmsGetValue;
|
|
_this.SetValue = _this.lmsSetValue;
|
|
_this.Commit = _this.lmsCommit;
|
|
_this.GetLastError = _this.lmsGetLastError;
|
|
_this.GetErrorString = _this.lmsGetErrorString;
|
|
_this.GetDiagnostic = _this.lmsGetDiagnostic;
|
|
return _this;
|
|
}
|
|
/**
|
|
* Getter for #version
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
_createClass(Scorm2004API, [{
|
|
key: "version",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _version);
|
|
}
|
|
/**
|
|
* @return {string} bool
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsInitialize",
|
|
value: function lmsInitialize() {
|
|
this.cmi.initialize();
|
|
return this.initialize('Initialize');
|
|
}
|
|
/**
|
|
* @return {string} bool
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsTerminate",
|
|
value: function lmsTerminate() {
|
|
var result = this.terminate('Terminate', true);
|
|
|
|
if (result === global_constants.SCORM_TRUE) {
|
|
if (this.adl.nav.request !== '_none_') {
|
|
switch (this.adl.nav.request) {
|
|
case 'continue':
|
|
this.processListeners('SequenceNext');
|
|
break;
|
|
|
|
case 'previous':
|
|
this.processListeners('SequencePrevious');
|
|
break;
|
|
|
|
case 'choice':
|
|
this.processListeners('SequenceChoice');
|
|
break;
|
|
|
|
case 'exit':
|
|
this.processListeners('SequenceExit');
|
|
break;
|
|
|
|
case 'exitAll':
|
|
this.processListeners('SequenceExitAll');
|
|
break;
|
|
|
|
case 'abandon':
|
|
this.processListeners('SequenceAbandon');
|
|
break;
|
|
|
|
case 'abandonAll':
|
|
this.processListeners('SequenceAbandonAll');
|
|
break;
|
|
}
|
|
} else if (this.settings.autoProgress) {
|
|
this.processListeners('SequenceNext');
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
/**
|
|
* @param {string} CMIElement
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsGetValue",
|
|
value: function lmsGetValue(CMIElement) {
|
|
return this.getValue('GetValue', true, CMIElement);
|
|
}
|
|
/**
|
|
* @param {string} CMIElement
|
|
* @param {any} value
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsSetValue",
|
|
value: function lmsSetValue(CMIElement, value) {
|
|
return this.setValue('SetValue', 'Commit', true, CMIElement, value);
|
|
}
|
|
/**
|
|
* Orders LMS to store all content parameters
|
|
*
|
|
* @return {string} bool
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsCommit",
|
|
value: function lmsCommit() {
|
|
return this.commit('Commit');
|
|
}
|
|
/**
|
|
* Returns last error code
|
|
*
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsGetLastError",
|
|
value: function lmsGetLastError() {
|
|
return this.getLastError('GetLastError');
|
|
}
|
|
/**
|
|
* Returns the errorNumber error description
|
|
*
|
|
* @param {(string|number)} CMIErrorCode
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsGetErrorString",
|
|
value: function lmsGetErrorString(CMIErrorCode) {
|
|
return this.getErrorString('GetErrorString', CMIErrorCode);
|
|
}
|
|
/**
|
|
* Returns a comprehensive description of the errorNumber error.
|
|
*
|
|
* @param {(string|number)} CMIErrorCode
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "lmsGetDiagnostic",
|
|
value: function lmsGetDiagnostic(CMIErrorCode) {
|
|
return this.getDiagnostic('GetDiagnostic', CMIErrorCode);
|
|
}
|
|
/**
|
|
* Sets a value on the CMI Object
|
|
*
|
|
* @param {string} CMIElement
|
|
* @param {any} value
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "setCMIValue",
|
|
value: function setCMIValue(CMIElement, value) {
|
|
return this._commonSetCMIValue('SetValue', true, CMIElement, value);
|
|
}
|
|
/**
|
|
* Gets or builds a new child element to add to the array.
|
|
*
|
|
* @param {string} CMIElement
|
|
* @param {any} value
|
|
* @param {boolean} foundFirstIndex
|
|
* @return {any}
|
|
*/
|
|
|
|
}, {
|
|
key: "getChildElement",
|
|
value: function getChildElement(CMIElement, value, foundFirstIndex) {
|
|
var newChild;
|
|
|
|
if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) {
|
|
newChild = new _scorm2004_cmi.CMIObjectivesObject();
|
|
} else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) {
|
|
var parts = CMIElement.split('.');
|
|
var index = Number(parts[2]);
|
|
var interaction = this.cmi.interactions.childArray[index];
|
|
|
|
if (this.isInitialized()) {
|
|
if (!interaction.type) {
|
|
this.throwSCORMError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);
|
|
} else {
|
|
this.checkDuplicateChoiceResponse(interaction, value);
|
|
var response_type = correct_responses[interaction.type];
|
|
|
|
if (response_type) {
|
|
this.checkValidResponseType(response_type, value, interaction.type);
|
|
} else {
|
|
this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Incorrect Response Type: ' + interaction.type);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.lastErrorCode === 0) {
|
|
newChild = new _scorm2004_cmi.CMIInteractionsCorrectResponsesObject();
|
|
}
|
|
} else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) {
|
|
newChild = new _scorm2004_cmi.CMIInteractionsObjectivesObject();
|
|
} else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) {
|
|
newChild = new _scorm2004_cmi.CMIInteractionsObject();
|
|
} else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_learner\\.\\d+')) {
|
|
newChild = new _scorm2004_cmi.CMICommentsObject();
|
|
} else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_lms\\.\\d+')) {
|
|
newChild = new _scorm2004_cmi.CMICommentsObject(true);
|
|
}
|
|
|
|
return newChild;
|
|
}
|
|
/**
|
|
* Checks for valid response types
|
|
* @param {object} response_type
|
|
* @param {any} value
|
|
* @param {string} interaction_type
|
|
*/
|
|
|
|
}, {
|
|
key: "checkValidResponseType",
|
|
value: function checkValidResponseType(response_type, value, interaction_type) {
|
|
var nodes = [];
|
|
|
|
if (response_type !== null && response_type !== void 0 && response_type.delimiter) {
|
|
nodes = String(value).split(response_type.delimiter);
|
|
} else {
|
|
nodes[0] = value;
|
|
}
|
|
|
|
if (nodes.length > 0 && nodes.length <= response_type.max) {
|
|
this.checkCorrectResponseValue(interaction_type, nodes, value);
|
|
} else if (nodes.length > response_type.max) {
|
|
this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Too Long');
|
|
}
|
|
}
|
|
/**
|
|
* Checks for duplicate 'choice' responses.
|
|
* @param {CMIInteractionsObject} interaction
|
|
* @param {any} value
|
|
*/
|
|
|
|
}, {
|
|
key: "checkDuplicateChoiceResponse",
|
|
value: function checkDuplicateChoiceResponse(interaction, value) {
|
|
var interaction_count = interaction.correct_responses._count;
|
|
|
|
if (interaction.type === 'choice') {
|
|
for (var i = 0; i < interaction_count && this.lastErrorCode === 0; i++) {
|
|
var response = interaction.correct_responses.childArray[i];
|
|
|
|
if (response.pattern === value) {
|
|
this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Validate correct response.
|
|
* @param {string} CMIElement
|
|
* @param {*} value
|
|
*/
|
|
|
|
}, {
|
|
key: "validateCorrectResponse",
|
|
value: function validateCorrectResponse(CMIElement, value) {
|
|
var parts = CMIElement.split('.');
|
|
var index = Number(parts[2]);
|
|
var pattern_index = Number(parts[4]);
|
|
var interaction = this.cmi.interactions.childArray[index];
|
|
var interaction_count = interaction.correct_responses._count;
|
|
this.checkDuplicateChoiceResponse(interaction, value);
|
|
var response_type = correct_responses[interaction.type];
|
|
|
|
if (typeof response_type.limit === 'undefined' || interaction_count <= response_type.limit) {
|
|
this.checkValidResponseType(response_type, value, interaction.type);
|
|
|
|
if (this.lastErrorCode === 0 && (!response_type.duplicate || !this.checkDuplicatedPattern(interaction.correct_responses, pattern_index, value)) || this.lastErrorCode === 0 && value === '') {// do nothing, we want the inverse
|
|
} else {
|
|
if (this.lastErrorCode === 0) {
|
|
this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Already Exists');
|
|
}
|
|
}
|
|
} else {
|
|
this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Collection Limit Reached');
|
|
}
|
|
}
|
|
/**
|
|
* Gets a value from the CMI Object
|
|
*
|
|
* @param {string} CMIElement
|
|
* @return {*}
|
|
*/
|
|
|
|
}, {
|
|
key: "getCMIValue",
|
|
value: function getCMIValue(CMIElement) {
|
|
return this._commonGetCMIValue('GetValue', true, CMIElement);
|
|
}
|
|
/**
|
|
* Returns the message that corresponds to errorNumber.
|
|
*
|
|
* @param {(string|number)} errorNumber
|
|
* @param {boolean} detail
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "getLmsErrorMessageDetails",
|
|
value: function getLmsErrorMessageDetails(errorNumber, detail) {
|
|
var basicMessage = '';
|
|
var detailMessage = ''; // Set error number to string since inconsistent from modules if string or number
|
|
|
|
errorNumber = String(errorNumber);
|
|
|
|
if (scorm2004_constants.error_descriptions[errorNumber]) {
|
|
basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage;
|
|
detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage;
|
|
}
|
|
|
|
return detail ? detailMessage : basicMessage;
|
|
}
|
|
/**
|
|
* Check to see if a correct_response value has been duplicated
|
|
* @param {CMIArray} correct_response
|
|
* @param {number} current_index
|
|
* @param {*} value
|
|
* @return {boolean}
|
|
*/
|
|
|
|
}, {
|
|
key: "checkCorrectResponseValue",
|
|
value:
|
|
/**
|
|
* Checks for a valid correct_response value
|
|
* @param {string} interaction_type
|
|
* @param {Array} nodes
|
|
* @param {*} value
|
|
*/
|
|
function checkCorrectResponseValue(interaction_type, nodes, value) {
|
|
var response = correct_responses[interaction_type];
|
|
var formatRegex = new RegExp(response.format);
|
|
|
|
for (var i = 0; i < nodes.length && this.lastErrorCode === 0; i++) {
|
|
if (interaction_type.match('^(fill-in|long-fill-in|matching|performance|sequencing)$')) {
|
|
nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]);
|
|
}
|
|
|
|
if (response !== null && response !== void 0 && response.delimiter2) {
|
|
var values = nodes[i].split(response.delimiter2);
|
|
|
|
if (values.length === 2) {
|
|
var matches = values[0].match(formatRegex);
|
|
|
|
if (!matches) {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
} else {
|
|
if (!values[1].match(new RegExp(response.format2))) {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
}
|
|
} else {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
} else {
|
|
var _matches = nodes[i].match(formatRegex);
|
|
|
|
if (!_matches && value !== '' || !_matches && interaction_type === 'true-false') {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
} else {
|
|
if (interaction_type === 'numeric' && nodes.length > 1) {
|
|
if (Number(nodes[0]) > Number(nodes[1])) {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
} else {
|
|
if (nodes[i] !== '' && response.unique) {
|
|
for (var j = 0; j < i && this.lastErrorCode === 0; j++) {
|
|
if (nodes[i] === nodes[j]) {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Remove prefixes from correct_response
|
|
* @param {string} node
|
|
* @return {*}
|
|
*/
|
|
|
|
}, {
|
|
key: "removeCorrectResponsePrefixes",
|
|
value: function removeCorrectResponsePrefixes(node) {
|
|
var seenOrder = false;
|
|
var seenCase = false;
|
|
var seenLang = false;
|
|
var prefixRegex = new RegExp('^({(lang|case_matters|order_matters)=([^}]+)})');
|
|
var matches = node.match(prefixRegex);
|
|
var langMatches = null;
|
|
|
|
while (matches) {
|
|
switch (matches[2]) {
|
|
case 'lang':
|
|
langMatches = node.match(scorm2004_regex.CMILangcr);
|
|
|
|
if (langMatches) {
|
|
var lang = langMatches[3];
|
|
|
|
if (lang !== undefined && lang.length > 0) {
|
|
if (_language_constants["default"][lang.toLowerCase()] === undefined) {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
}
|
|
}
|
|
|
|
seenLang = true;
|
|
break;
|
|
|
|
case 'case_matters':
|
|
if (!seenLang && !seenOrder && !seenCase) {
|
|
if (matches[3] !== 'true' && matches[3] !== 'false') {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
}
|
|
|
|
seenCase = true;
|
|
break;
|
|
|
|
case 'order_matters':
|
|
if (!seenCase && !seenLang && !seenOrder) {
|
|
if (matches[3] !== 'true' && matches[3] !== 'false') {
|
|
this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
}
|
|
|
|
seenOrder = true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
node = node.substr(matches[1].length);
|
|
matches = node.match(prefixRegex);
|
|
}
|
|
|
|
return node;
|
|
}
|
|
/**
|
|
* Replace the whole API with another
|
|
* @param {Scorm2004API} newAPI
|
|
*/
|
|
|
|
}, {
|
|
key: "replaceWithAnotherScormAPI",
|
|
value: function replaceWithAnotherScormAPI(newAPI) {
|
|
// Data Model
|
|
this.cmi = newAPI.cmi;
|
|
this.adl = newAPI.adl;
|
|
}
|
|
/**
|
|
* Render the cmi object to the proper format for LMS commit
|
|
*
|
|
* @param {boolean} terminateCommit
|
|
* @return {object|Array}
|
|
*/
|
|
|
|
}, {
|
|
key: "renderCommitCMI",
|
|
value: function renderCommitCMI(terminateCommit) {
|
|
var cmiExport = this.renderCMIToJSONObject();
|
|
|
|
if (terminateCommit) {
|
|
cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime();
|
|
}
|
|
|
|
var result = [];
|
|
var flattened = Utilities.flatten(cmiExport);
|
|
|
|
switch (this.settings.dataCommitFormat) {
|
|
case 'flattened':
|
|
return Utilities.flatten(cmiExport);
|
|
|
|
case 'params':
|
|
for (var item in flattened) {
|
|
if ({}.hasOwnProperty.call(flattened, item)) {
|
|
result.push("".concat(item, "=").concat(flattened[item]));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
|
|
case 'json':
|
|
default:
|
|
return cmiExport;
|
|
}
|
|
}
|
|
/**
|
|
* Attempts to store the data to the LMS
|
|
*
|
|
* @param {boolean} terminateCommit
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "storeData",
|
|
value: function storeData(terminateCommit) {
|
|
var _this$startingData, _this$startingData$ad, _this$startingData$ad2;
|
|
|
|
if (terminateCommit) {
|
|
if (this.cmi.mode === 'normal') {
|
|
if (this.cmi.credit === 'credit') {
|
|
if (this.cmi.completion_threshold && this.cmi.progress_measure) {
|
|
if (this.cmi.progress_measure >= this.cmi.completion_threshold) {
|
|
console.debug('Setting Completion Status: Completed');
|
|
this.cmi.completion_status = 'completed';
|
|
} else {
|
|
console.debug('Setting Completion Status: Incomplete');
|
|
this.cmi.completion_status = 'incomplete';
|
|
}
|
|
}
|
|
|
|
if (this.cmi.scaled_passing_score && this.cmi.score.scaled) {
|
|
if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) {
|
|
console.debug('Setting Success Status: Passed');
|
|
this.cmi.success_status = 'passed';
|
|
} else {
|
|
console.debug('Setting Success Status: Failed');
|
|
this.cmi.success_status = 'failed';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var navRequest = false;
|
|
|
|
if (this.adl.nav.request !== ((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$ad = _this$startingData.adl) === null || _this$startingData$ad === void 0 ? void 0 : (_this$startingData$ad2 = _this$startingData$ad.nav) === null || _this$startingData$ad2 === void 0 ? void 0 : _this$startingData$ad2.request) && this.adl.nav.request !== '_none_') {
|
|
this.adl.nav.request = encodeURIComponent(this.adl.nav.request);
|
|
navRequest = true;
|
|
}
|
|
|
|
var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime);
|
|
|
|
if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {
|
|
console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): ');
|
|
console.debug(commitObject);
|
|
}
|
|
|
|
if (this.settings.lmsCommitUrl) {
|
|
var result = this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); // check if this is a sequencing call, and then call the necessary JS
|
|
|
|
{
|
|
if (navRequest && result.navRequest !== undefined && result.navRequest !== '') {
|
|
Function("\"use strict\";(() => { ".concat(result.navRequest, " })()"))();
|
|
}
|
|
}
|
|
return result;
|
|
} else {
|
|
return global_constants.SCORM_TRUE;
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return Scorm2004API;
|
|
}(_BaseAPI2["default"]);
|
|
|
|
exports["default"] = Scorm2004API;
|
|
|
|
},{"./BaseAPI":2,"./cmi/scorm2004_cmi":5,"./constants/api_constants":6,"./constants/error_codes":7,"./constants/language_constants":8,"./constants/regex":9,"./constants/response_constants":10,"./utilities":13}],4:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.checkValidFormat = checkValidFormat;
|
|
exports.checkValidRange = checkValidRange;
|
|
exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0;
|
|
|
|
var _api_constants = _interopRequireDefault(require("../constants/api_constants"));
|
|
|
|
var _error_codes = _interopRequireDefault(require("../constants/error_codes"));
|
|
|
|
var _regex = _interopRequireDefault(require("../constants/regex"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
|
|
|
|
function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
var scorm12_constants = _api_constants["default"].scorm12;
|
|
var scorm12_regex = _regex["default"].scorm12;
|
|
var scorm12_error_codes = _error_codes["default"].scorm12;
|
|
/**
|
|
* Check if the value matches the proper format. If not, throw proper error code.
|
|
*
|
|
* @param {string} value
|
|
* @param {string} regexPattern
|
|
* @param {number} errorCode
|
|
* @param {class} errorClass
|
|
* @param {boolean} allowEmptyString
|
|
* @return {boolean}
|
|
*/
|
|
|
|
function checkValidFormat(value, regexPattern, errorCode, errorClass, allowEmptyString) {
|
|
var formatRegex = new RegExp(regexPattern);
|
|
var matches = value.match(formatRegex);
|
|
|
|
if (allowEmptyString && value === '') {
|
|
return true;
|
|
}
|
|
|
|
if (value === undefined || !matches || matches[0] === '') {
|
|
throw new errorClass.prototype.constructor(errorCode);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
/**
|
|
* Check if the value matches the proper range. If not, throw proper error code.
|
|
*
|
|
* @param {*} value
|
|
* @param {string} rangePattern
|
|
* @param {number} errorCode
|
|
* @param {class} errorClass
|
|
* @return {boolean}
|
|
*/
|
|
|
|
|
|
function checkValidRange(value, rangePattern, errorCode, errorClass) {
|
|
var ranges = rangePattern.split('#');
|
|
value = value * 1.0;
|
|
|
|
if (value >= ranges[0]) {
|
|
if (ranges[1] === '*' || value <= ranges[1]) {
|
|
return true;
|
|
} else {
|
|
throw new errorClass.prototype.constructor(errorCode);
|
|
}
|
|
} else {
|
|
throw new errorClass.prototype.constructor(errorCode);
|
|
}
|
|
}
|
|
/**
|
|
* Base class for API cmi objects
|
|
*/
|
|
|
|
|
|
var _initialized = /*#__PURE__*/new WeakMap();
|
|
|
|
var _start_time = /*#__PURE__*/new WeakMap();
|
|
|
|
var BaseCMI = /*#__PURE__*/function () {
|
|
/**
|
|
* Constructor for BaseCMI, just marks the class as abstract
|
|
*/
|
|
function BaseCMI() {
|
|
_classCallCheck(this, BaseCMI);
|
|
|
|
_defineProperty(this, "jsonString", false);
|
|
|
|
_initialized.set(this, {
|
|
writable: true,
|
|
value: false
|
|
});
|
|
|
|
_start_time.set(this, {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) {
|
|
throw new TypeError('Cannot construct BaseCMI instances directly');
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #initialized
|
|
* @return {boolean}
|
|
*/
|
|
|
|
|
|
_createClass(BaseCMI, [{
|
|
key: "initialized",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _initialized);
|
|
}
|
|
/**
|
|
* Getter for #start_time
|
|
* @return {Number}
|
|
*/
|
|
|
|
}, {
|
|
key: "start_time",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _start_time);
|
|
}
|
|
/**
|
|
* Called when the API has been initialized after the CMI has been created
|
|
*/
|
|
|
|
}, {
|
|
key: "initialize",
|
|
value: function initialize() {
|
|
_classPrivateFieldSet(this, _initialized, true);
|
|
}
|
|
/**
|
|
* Called when the player should override the 'session_time' provided by
|
|
* the module
|
|
*/
|
|
|
|
}, {
|
|
key: "setStartTime",
|
|
value: function setStartTime() {
|
|
_classPrivateFieldSet(this, _start_time, new Date().getTime());
|
|
}
|
|
}]);
|
|
|
|
return BaseCMI;
|
|
}();
|
|
/**
|
|
* Base class for cmi *.score objects
|
|
*/
|
|
|
|
|
|
exports.BaseCMI = BaseCMI;
|
|
|
|
var _children2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _score_range = /*#__PURE__*/new WeakMap();
|
|
|
|
var _invalid_error_code = /*#__PURE__*/new WeakMap();
|
|
|
|
var _invalid_type_code = /*#__PURE__*/new WeakMap();
|
|
|
|
var _invalid_range_code = /*#__PURE__*/new WeakMap();
|
|
|
|
var _decimal_regex = /*#__PURE__*/new WeakMap();
|
|
|
|
var _error_class = /*#__PURE__*/new WeakMap();
|
|
|
|
var _raw = /*#__PURE__*/new WeakMap();
|
|
|
|
var _min = /*#__PURE__*/new WeakMap();
|
|
|
|
var _max = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMIScore = /*#__PURE__*/function (_BaseCMI) {
|
|
_inherits(CMIScore, _BaseCMI);
|
|
|
|
var _super = _createSuper(CMIScore);
|
|
|
|
/**
|
|
* Constructor for *.score
|
|
* @param {string} score_children
|
|
* @param {string} score_range
|
|
* @param {string} max
|
|
* @param {number} invalidErrorCode
|
|
* @param {number} invalidTypeCode
|
|
* @param {number} invalidRangeCode
|
|
* @param {string} decimalRegex
|
|
* @param {class} errorClass
|
|
*/
|
|
function CMIScore(_ref) {
|
|
var _this;
|
|
|
|
var score_children = _ref.score_children,
|
|
score_range = _ref.score_range,
|
|
max = _ref.max,
|
|
invalidErrorCode = _ref.invalidErrorCode,
|
|
invalidTypeCode = _ref.invalidTypeCode,
|
|
invalidRangeCode = _ref.invalidRangeCode,
|
|
decimalRegex = _ref.decimalRegex,
|
|
errorClass = _ref.errorClass;
|
|
|
|
_classCallCheck(this, CMIScore);
|
|
|
|
_this = _super.call(this);
|
|
|
|
_children2.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_score_range.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_invalid_error_code.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_invalid_type_code.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_invalid_range_code.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_decimal_regex.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_error_class.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_raw.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_min.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_max.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100');
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass);
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(CMIScore, [{
|
|
key: "_children",
|
|
get:
|
|
/**
|
|
* Getter for _children
|
|
* @return {string}
|
|
* @private
|
|
*/
|
|
function get() {
|
|
return _classPrivateFieldGet(this, _children2);
|
|
}
|
|
/**
|
|
* Setter for _children. Just throws an error.
|
|
* @param {string} _children
|
|
* @private
|
|
*/
|
|
,
|
|
set: function set(_children) {
|
|
throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code));
|
|
}
|
|
/**
|
|
* Getter for #raw
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "raw",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _raw);
|
|
}
|
|
/**
|
|
* Setter for #raw
|
|
* @param {string} raw
|
|
*/
|
|
,
|
|
set: function set(raw) {
|
|
if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) {
|
|
_classPrivateFieldSet(this, _raw, raw);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #min
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "min",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _min);
|
|
}
|
|
/**
|
|
* Setter for #min
|
|
* @param {string} min
|
|
*/
|
|
,
|
|
set: function set(min) {
|
|
if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) {
|
|
_classPrivateFieldSet(this, _min, min);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #max
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "max",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _max);
|
|
}
|
|
/**
|
|
* Setter for #max
|
|
* @param {string} max
|
|
*/
|
|
,
|
|
set: function set(max) {
|
|
if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) {
|
|
_classPrivateFieldSet(this, _max, max);
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for *.score
|
|
* @return {{min: string, max: string, raw: string}}
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'raw': this.raw,
|
|
'min': this.min,
|
|
'max': this.max
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMIScore;
|
|
}(BaseCMI);
|
|
/**
|
|
* Base class for cmi *.n objects
|
|
*/
|
|
|
|
|
|
exports.CMIScore = CMIScore;
|
|
|
|
var _errorCode = /*#__PURE__*/new WeakMap();
|
|
|
|
var _errorClass = /*#__PURE__*/new WeakMap();
|
|
|
|
var _children3 = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMIArray = /*#__PURE__*/function (_BaseCMI2) {
|
|
_inherits(CMIArray, _BaseCMI2);
|
|
|
|
var _super2 = _createSuper(CMIArray);
|
|
|
|
/**
|
|
* Constructor cmi *.n arrays
|
|
* @param {string} children
|
|
* @param {number} errorCode
|
|
* @param {class} errorClass
|
|
*/
|
|
function CMIArray(_ref2) {
|
|
var _this2;
|
|
|
|
var children = _ref2.children,
|
|
errorCode = _ref2.errorCode,
|
|
errorClass = _ref2.errorClass;
|
|
|
|
_classCallCheck(this, CMIArray);
|
|
|
|
_this2 = _super2.call(this);
|
|
|
|
_errorCode.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_errorClass.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_children3.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass);
|
|
|
|
_this2.childArray = [];
|
|
return _this2;
|
|
}
|
|
|
|
_createClass(CMIArray, [{
|
|
key: "_children",
|
|
get:
|
|
/**
|
|
* Getter for _children
|
|
* @return {*}
|
|
*/
|
|
function get() {
|
|
return _classPrivateFieldGet(this, _children3);
|
|
}
|
|
/**
|
|
* Setter for _children. Just throws an error.
|
|
* @param {string} _children
|
|
*/
|
|
,
|
|
set: function set(_children) {
|
|
throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode));
|
|
}
|
|
/**
|
|
* Getter for _count
|
|
* @return {number}
|
|
*/
|
|
|
|
}, {
|
|
key: "_count",
|
|
get: function get() {
|
|
return this.childArray.length;
|
|
}
|
|
/**
|
|
* Setter for _count. Just throws an error.
|
|
* @param {number} _count
|
|
*/
|
|
,
|
|
set: function set(_count) {
|
|
throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode));
|
|
}
|
|
/**
|
|
* toJSON for *.n arrays
|
|
* @return {object}
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {};
|
|
|
|
for (var i = 0; i < this.childArray.length; i++) {
|
|
result[i + ''] = this.childArray[i];
|
|
}
|
|
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMIArray;
|
|
}(BaseCMI);
|
|
|
|
exports.CMIArray = CMIArray;
|
|
|
|
},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":9}],5:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.ADL = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMICommentsObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMI = void 0;
|
|
|
|
var _common = require("./common");
|
|
|
|
var _api_constants = _interopRequireDefault(require("../constants/api_constants"));
|
|
|
|
var _regex = _interopRequireDefault(require("../constants/regex"));
|
|
|
|
var _error_codes = _interopRequireDefault(require("../constants/error_codes"));
|
|
|
|
var _response_constants = _interopRequireDefault(require("../constants/response_constants"));
|
|
|
|
var _exceptions = require("../exceptions");
|
|
|
|
var Util = _interopRequireWildcard(require("../utilities"));
|
|
|
|
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
|
|
|
|
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
|
|
|
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
|
|
|
|
function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
var scorm2004_constants = _api_constants["default"].scorm2004;
|
|
var scorm2004_error_codes = _error_codes["default"].scorm2004;
|
|
var learner_responses = _response_constants["default"].learner;
|
|
var scorm2004_regex = _regex["default"].scorm2004;
|
|
/**
|
|
* Helper method for throwing Read Only error
|
|
*/
|
|
|
|
function throwReadOnlyError() {
|
|
throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);
|
|
}
|
|
/**
|
|
* Helper method for throwing Write Only error
|
|
*/
|
|
|
|
|
|
function throwWriteOnlyError() {
|
|
throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);
|
|
}
|
|
/**
|
|
* Helper method for throwing Type Mismatch error
|
|
*/
|
|
|
|
|
|
function throwTypeMismatchError() {
|
|
throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH);
|
|
}
|
|
/**
|
|
* Helper method for throwing Dependency Not Established error
|
|
*/
|
|
|
|
|
|
function throwDependencyNotEstablishedError() {
|
|
throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);
|
|
}
|
|
/**
|
|
* Helper method for throwing Dependency Not Established error
|
|
*/
|
|
|
|
|
|
function throwGeneralSetError() {
|
|
throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);
|
|
}
|
|
/**
|
|
* Helper method, no reason to have to pass the same error codes every time
|
|
* @param {*} value
|
|
* @param {string} regexPattern
|
|
* @param {boolean} allowEmptyString
|
|
* @return {boolean}
|
|
*/
|
|
|
|
|
|
function check2004ValidFormat(value, regexPattern, allowEmptyString) {
|
|
return (0, _common.checkValidFormat)(value, regexPattern, scorm2004_error_codes.TYPE_MISMATCH, _exceptions.Scorm2004ValidationError, allowEmptyString);
|
|
}
|
|
/**
|
|
* Helper method, no reason to have to pass the same error codes every time
|
|
* @param {*} value
|
|
* @param {string} rangePattern
|
|
* @return {boolean}
|
|
*/
|
|
|
|
|
|
function check2004ValidRange(value, rangePattern) {
|
|
return (0, _common.checkValidRange)(value, rangePattern, scorm2004_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm2004ValidationError);
|
|
}
|
|
/**
|
|
* Class representing cmi object for SCORM 2004
|
|
*/
|
|
|
|
|
|
var _version2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _children2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _completion_status = /*#__PURE__*/new WeakMap();
|
|
|
|
var _completion_threshold = /*#__PURE__*/new WeakMap();
|
|
|
|
var _credit = /*#__PURE__*/new WeakMap();
|
|
|
|
var _entry = /*#__PURE__*/new WeakMap();
|
|
|
|
var _exit = /*#__PURE__*/new WeakMap();
|
|
|
|
var _launch_data = /*#__PURE__*/new WeakMap();
|
|
|
|
var _learner_id = /*#__PURE__*/new WeakMap();
|
|
|
|
var _learner_name = /*#__PURE__*/new WeakMap();
|
|
|
|
var _location = /*#__PURE__*/new WeakMap();
|
|
|
|
var _max_time_allowed = /*#__PURE__*/new WeakMap();
|
|
|
|
var _mode = /*#__PURE__*/new WeakMap();
|
|
|
|
var _progress_measure = /*#__PURE__*/new WeakMap();
|
|
|
|
var _scaled_passing_score = /*#__PURE__*/new WeakMap();
|
|
|
|
var _session_time = /*#__PURE__*/new WeakMap();
|
|
|
|
var _success_status = /*#__PURE__*/new WeakMap();
|
|
|
|
var _suspend_data = /*#__PURE__*/new WeakMap();
|
|
|
|
var _time_limit_action = /*#__PURE__*/new WeakMap();
|
|
|
|
var _total_time = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMI = /*#__PURE__*/function (_BaseCMI) {
|
|
_inherits(CMI, _BaseCMI);
|
|
|
|
var _super = _createSuper(CMI);
|
|
|
|
/**
|
|
* Constructor for the SCORM 2004 cmi object
|
|
* @param {boolean} initialized
|
|
*/
|
|
function CMI(initialized) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, CMI);
|
|
|
|
_this = _super.call(this);
|
|
|
|
_version2.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: '1.0'
|
|
});
|
|
|
|
_children2.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: scorm2004_constants.cmi_children
|
|
});
|
|
|
|
_completion_status.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: 'unknown'
|
|
});
|
|
|
|
_completion_threshold.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_credit.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: 'credit'
|
|
});
|
|
|
|
_entry.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_exit.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_launch_data.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_learner_id.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_learner_name.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_location.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_max_time_allowed.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_mode.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: 'normal'
|
|
});
|
|
|
|
_progress_measure.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_scaled_passing_score.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_session_time.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: 'PT0H0M0S'
|
|
});
|
|
|
|
_success_status.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: 'unknown'
|
|
});
|
|
|
|
_suspend_data.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_time_limit_action.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: 'continue,no message'
|
|
});
|
|
|
|
_total_time.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_this.learner_preference = new CMILearnerPreference();
|
|
_this.score = new Scorm2004CMIScore();
|
|
_this.comments_from_learner = new CMICommentsFromLearner();
|
|
_this.comments_from_lms = new CMICommentsFromLMS();
|
|
_this.interactions = new CMIInteractions();
|
|
_this.objectives = new CMIObjectives();
|
|
if (initialized) _this.initialize();
|
|
return _this;
|
|
}
|
|
|
|
_createClass(CMI, [{
|
|
key: "initialize",
|
|
value:
|
|
/**
|
|
* Called when the API has been initialized after the CMI has been created
|
|
*/
|
|
function initialize() {
|
|
var _this$learner_prefere, _this$score, _this$comments_from_l, _this$comments_from_l2, _this$interactions, _this$objectives;
|
|
|
|
_get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this);
|
|
|
|
(_this$learner_prefere = this.learner_preference) === null || _this$learner_prefere === void 0 ? void 0 : _this$learner_prefere.initialize();
|
|
(_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize();
|
|
(_this$comments_from_l = this.comments_from_learner) === null || _this$comments_from_l === void 0 ? void 0 : _this$comments_from_l.initialize();
|
|
(_this$comments_from_l2 = this.comments_from_lms) === null || _this$comments_from_l2 === void 0 ? void 0 : _this$comments_from_l2.initialize();
|
|
(_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize();
|
|
(_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize();
|
|
}
|
|
/**
|
|
* Getter for #_version
|
|
* @return {string}
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: "_version",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _version2);
|
|
}
|
|
/**
|
|
* Setter for #_version. Just throws an error.
|
|
* @param {string} _version
|
|
* @private
|
|
*/
|
|
,
|
|
set: function set(_version) {
|
|
throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #_children
|
|
* @return {string}
|
|
* @private
|
|
*/
|
|
|
|
}, {
|
|
key: "_children",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _children2);
|
|
}
|
|
/**
|
|
* Setter for #_children. Just throws an error.
|
|
* @param {number} _children
|
|
* @private
|
|
*/
|
|
,
|
|
set: function set(_children) {
|
|
throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #completion_status
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "completion_status",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _completion_status);
|
|
}
|
|
/**
|
|
* Setter for #completion_status
|
|
* @param {string} completion_status
|
|
*/
|
|
,
|
|
set: function set(completion_status) {
|
|
if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {
|
|
_classPrivateFieldSet(this, _completion_status, completion_status);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #completion_threshold
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "completion_threshold",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _completion_threshold);
|
|
}
|
|
/**
|
|
* Setter for #completion_threshold. Can only be called before initialization.
|
|
* @param {string} completion_threshold
|
|
*/
|
|
,
|
|
set: function set(completion_threshold) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _completion_threshold, completion_threshold) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Setter for #credit
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "credit",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _credit);
|
|
}
|
|
/**
|
|
* Setter for #credit. Can only be called before initialization.
|
|
* @param {string} credit
|
|
*/
|
|
,
|
|
set: function set(credit) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #entry
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "entry",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _entry);
|
|
}
|
|
/**
|
|
* Setter for #entry. Can only be called before initialization.
|
|
* @param {string} entry
|
|
*/
|
|
,
|
|
set: function set(entry) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #exit. Should only be called during JSON export.
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "exit",
|
|
get: function get() {
|
|
return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit);
|
|
}
|
|
/**
|
|
* Getter for #exit
|
|
* @param {string} exit
|
|
*/
|
|
,
|
|
set: function set(exit) {
|
|
if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) {
|
|
_classPrivateFieldSet(this, _exit, exit);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #launch_data
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "launch_data",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _launch_data);
|
|
}
|
|
/**
|
|
* Setter for #launch_data. Can only be called before initialization.
|
|
* @param {string} launch_data
|
|
*/
|
|
,
|
|
set: function set(launch_data) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #learner_id
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "learner_id",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _learner_id);
|
|
}
|
|
/**
|
|
* Setter for #learner_id. Can only be called before initialization.
|
|
* @param {string} learner_id
|
|
*/
|
|
,
|
|
set: function set(learner_id) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _learner_id, learner_id) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #learner_name
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "learner_name",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _learner_name);
|
|
}
|
|
/**
|
|
* Setter for #learner_name. Can only be called before initialization.
|
|
* @param {string} learner_name
|
|
*/
|
|
,
|
|
set: function set(learner_name) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _learner_name, learner_name) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #location
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "location",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _location);
|
|
}
|
|
/**
|
|
* Setter for #location
|
|
* @param {string} location
|
|
*/
|
|
,
|
|
set: function set(location) {
|
|
if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) {
|
|
_classPrivateFieldSet(this, _location, location);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #max_time_allowed
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "max_time_allowed",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _max_time_allowed);
|
|
}
|
|
/**
|
|
* Setter for #max_time_allowed. Can only be called before initialization.
|
|
* @param {string} max_time_allowed
|
|
*/
|
|
,
|
|
set: function set(max_time_allowed) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #mode
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "mode",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _mode);
|
|
}
|
|
/**
|
|
* Setter for #mode. Can only be called before initialization.
|
|
* @param {string} mode
|
|
*/
|
|
,
|
|
set: function set(mode) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _mode, mode) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #progress_measure
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "progress_measure",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _progress_measure);
|
|
}
|
|
/**
|
|
* Setter for #progress_measure
|
|
* @param {string} progress_measure
|
|
*/
|
|
,
|
|
set: function set(progress_measure) {
|
|
if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) {
|
|
_classPrivateFieldSet(this, _progress_measure, progress_measure);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #scaled_passing_score
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "scaled_passing_score",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _scaled_passing_score);
|
|
}
|
|
/**
|
|
* Setter for #scaled_passing_score. Can only be called before initialization.
|
|
* @param {string} scaled_passing_score
|
|
*/
|
|
,
|
|
set: function set(scaled_passing_score) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _scaled_passing_score, scaled_passing_score) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #session_time. Should only be called during JSON export.
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "session_time",
|
|
get: function get() {
|
|
return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time);
|
|
}
|
|
/**
|
|
* Setter for #session_time
|
|
* @param {string} session_time
|
|
*/
|
|
,
|
|
set: function set(session_time) {
|
|
if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) {
|
|
_classPrivateFieldSet(this, _session_time, session_time);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #success_status
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "success_status",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _success_status);
|
|
}
|
|
/**
|
|
* Setter for #success_status
|
|
* @param {string} success_status
|
|
*/
|
|
,
|
|
set: function set(success_status) {
|
|
if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {
|
|
_classPrivateFieldSet(this, _success_status, success_status);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #suspend_data
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "suspend_data",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _suspend_data);
|
|
}
|
|
/**
|
|
* Setter for #suspend_data
|
|
* @param {string} suspend_data
|
|
*/
|
|
,
|
|
set: function set(suspend_data) {
|
|
if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000, true)) {
|
|
_classPrivateFieldSet(this, _suspend_data, suspend_data);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #time_limit_action
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "time_limit_action",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _time_limit_action);
|
|
}
|
|
/**
|
|
* Setter for #time_limit_action. Can only be called before initialization.
|
|
* @param {string} time_limit_action
|
|
*/
|
|
,
|
|
set: function set(time_limit_action) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #total_time
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "total_time",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _total_time);
|
|
}
|
|
/**
|
|
* Setter for #total_time. Can only be called before initialization.
|
|
* @param {string} total_time
|
|
*/
|
|
,
|
|
set: function set(total_time) {
|
|
!this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Adds the current session time to the existing total time.
|
|
*
|
|
* @return {string} ISO8601 Duration
|
|
*/
|
|
|
|
}, {
|
|
key: "getCurrentTotalTime",
|
|
value: function getCurrentTotalTime() {
|
|
var sessionTime = _classPrivateFieldGet(this, _session_time);
|
|
|
|
var startTime = this.start_time;
|
|
|
|
if (typeof startTime !== 'undefined' && startTime !== null) {
|
|
var seconds = new Date().getTime() - startTime;
|
|
sessionTime = Util.getSecondsAsISODuration(seconds / 1000);
|
|
}
|
|
|
|
return Util.addTwoDurations(_classPrivateFieldGet(this, _total_time), sessionTime, scorm2004_regex.CMITimespan);
|
|
}
|
|
/**
|
|
* toJSON for cmi
|
|
*
|
|
* @return {
|
|
* {
|
|
* comments_from_learner: CMICommentsFromLearner,
|
|
* comments_from_lms: CMICommentsFromLMS,
|
|
* completion_status: string,
|
|
* completion_threshold: string,
|
|
* credit: string,
|
|
* entry: string,
|
|
* exit: string,
|
|
* interactions: CMIInteractions,
|
|
* launch_data: string,
|
|
* learner_id: string,
|
|
* learner_name: string,
|
|
* learner_preference: CMILearnerPreference,
|
|
* location: string,
|
|
* max_time_allowed: string,
|
|
* mode: string,
|
|
* objectives: CMIObjectives,
|
|
* progress_measure: string,
|
|
* scaled_passing_score: string,
|
|
* score: Scorm2004CMIScore,
|
|
* session_time: string,
|
|
* success_status: string,
|
|
* suspend_data: string,
|
|
* time_limit_action: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'comments_from_learner': this.comments_from_learner,
|
|
'comments_from_lms': this.comments_from_lms,
|
|
'completion_status': this.completion_status,
|
|
'completion_threshold': this.completion_threshold,
|
|
'credit': this.credit,
|
|
'entry': this.entry,
|
|
'exit': this.exit,
|
|
'interactions': this.interactions,
|
|
'launch_data': this.launch_data,
|
|
'learner_id': this.learner_id,
|
|
'learner_name': this.learner_name,
|
|
'learner_preference': this.learner_preference,
|
|
'location': this.location,
|
|
'max_time_allowed': this.max_time_allowed,
|
|
'mode': this.mode,
|
|
'objectives': this.objectives,
|
|
'progress_measure': this.progress_measure,
|
|
'scaled_passing_score': this.scaled_passing_score,
|
|
'score': this.score,
|
|
'session_time': this.session_time,
|
|
'success_status': this.success_status,
|
|
'suspend_data': this.suspend_data,
|
|
'time_limit_action': this.time_limit_action
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMI;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class for SCORM 2004's cmi.learner_preference object
|
|
*/
|
|
|
|
|
|
exports.CMI = CMI;
|
|
|
|
var _children3 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _audio_level = /*#__PURE__*/new WeakMap();
|
|
|
|
var _language = /*#__PURE__*/new WeakMap();
|
|
|
|
var _delivery_speed = /*#__PURE__*/new WeakMap();
|
|
|
|
var _audio_captioning = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMILearnerPreference = /*#__PURE__*/function (_BaseCMI2) {
|
|
_inherits(CMILearnerPreference, _BaseCMI2);
|
|
|
|
var _super2 = _createSuper(CMILearnerPreference);
|
|
|
|
/**
|
|
* Constructor for cmi.learner_preference
|
|
*/
|
|
function CMILearnerPreference() {
|
|
var _this2;
|
|
|
|
_classCallCheck(this, CMILearnerPreference);
|
|
|
|
_this2 = _super2.call(this);
|
|
|
|
_children3.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: scorm2004_constants.student_preference_children
|
|
});
|
|
|
|
_audio_level.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: '1'
|
|
});
|
|
|
|
_language.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_delivery_speed.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: '1'
|
|
});
|
|
|
|
_audio_captioning.set(_assertThisInitialized(_this2), {
|
|
writable: true,
|
|
value: '0'
|
|
});
|
|
|
|
return _this2;
|
|
}
|
|
/**
|
|
* Getter for #_children
|
|
* @return {string}
|
|
* @private
|
|
*/
|
|
|
|
|
|
_createClass(CMILearnerPreference, [{
|
|
key: "_children",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _children3);
|
|
}
|
|
/**
|
|
* Setter for #_children. Just throws an error.
|
|
* @param {string} _children
|
|
* @private
|
|
*/
|
|
,
|
|
set: function set(_children) {
|
|
throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #audio_level
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "audio_level",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _audio_level);
|
|
}
|
|
/**
|
|
* Setter for #audio_level
|
|
* @param {string} audio_level
|
|
*/
|
|
,
|
|
set: function set(audio_level) {
|
|
if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) && check2004ValidRange(audio_level, scorm2004_regex.audio_range)) {
|
|
_classPrivateFieldSet(this, _audio_level, audio_level);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #language
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "language",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _language);
|
|
}
|
|
/**
|
|
* Setter for #language
|
|
* @param {string} language
|
|
*/
|
|
,
|
|
set: function set(language) {
|
|
if (check2004ValidFormat(language, scorm2004_regex.CMILang)) {
|
|
_classPrivateFieldSet(this, _language, language);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #delivery_speed
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "delivery_speed",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _delivery_speed);
|
|
}
|
|
/**
|
|
* Setter for #delivery_speed
|
|
* @param {string} delivery_speed
|
|
*/
|
|
,
|
|
set: function set(delivery_speed) {
|
|
if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) && check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) {
|
|
_classPrivateFieldSet(this, _delivery_speed, delivery_speed);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #audio_captioning
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "audio_captioning",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _audio_captioning);
|
|
}
|
|
/**
|
|
* Setter for #audio_captioning
|
|
* @param {string} audio_captioning
|
|
*/
|
|
,
|
|
set: function set(audio_captioning) {
|
|
if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) && check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) {
|
|
_classPrivateFieldSet(this, _audio_captioning, audio_captioning);
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for cmi.learner_preference
|
|
*
|
|
* @return {
|
|
* {
|
|
* audio_level: string,
|
|
* language: string,
|
|
* delivery_speed: string,
|
|
* audio_captioning: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'audio_level': this.audio_level,
|
|
'language': this.language,
|
|
'delivery_speed': this.delivery_speed,
|
|
'audio_captioning': this.audio_captioning
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMILearnerPreference;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class representing SCORM 2004's cmi.interactions object
|
|
*/
|
|
|
|
|
|
var CMIInteractions = /*#__PURE__*/function (_CMIArray) {
|
|
_inherits(CMIInteractions, _CMIArray);
|
|
|
|
var _super3 = _createSuper(CMIInteractions);
|
|
|
|
/**
|
|
* Constructor for cmi.objectives Array
|
|
*/
|
|
function CMIInteractions() {
|
|
_classCallCheck(this, CMIInteractions);
|
|
|
|
return _super3.call(this, {
|
|
children: scorm2004_constants.interactions_children,
|
|
errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,
|
|
errorClass: _exceptions.Scorm2004ValidationError
|
|
});
|
|
}
|
|
|
|
return CMIInteractions;
|
|
}(_common.CMIArray);
|
|
/**
|
|
* Class representing SCORM 2004's cmi.objectives object
|
|
*/
|
|
|
|
|
|
var CMIObjectives = /*#__PURE__*/function (_CMIArray2) {
|
|
_inherits(CMIObjectives, _CMIArray2);
|
|
|
|
var _super4 = _createSuper(CMIObjectives);
|
|
|
|
/**
|
|
* Constructor for cmi.objectives Array
|
|
*/
|
|
function CMIObjectives() {
|
|
_classCallCheck(this, CMIObjectives);
|
|
|
|
return _super4.call(this, {
|
|
children: scorm2004_constants.objectives_children,
|
|
errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,
|
|
errorClass: _exceptions.Scorm2004ValidationError
|
|
});
|
|
}
|
|
|
|
return CMIObjectives;
|
|
}(_common.CMIArray);
|
|
/**
|
|
* Class representing SCORM 2004's cmi.comments_from_lms object
|
|
*/
|
|
|
|
|
|
var CMICommentsFromLMS = /*#__PURE__*/function (_CMIArray3) {
|
|
_inherits(CMICommentsFromLMS, _CMIArray3);
|
|
|
|
var _super5 = _createSuper(CMICommentsFromLMS);
|
|
|
|
/**
|
|
* Constructor for cmi.comments_from_lms Array
|
|
*/
|
|
function CMICommentsFromLMS() {
|
|
_classCallCheck(this, CMICommentsFromLMS);
|
|
|
|
return _super5.call(this, {
|
|
children: scorm2004_constants.comments_children,
|
|
errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,
|
|
errorClass: _exceptions.Scorm2004ValidationError
|
|
});
|
|
}
|
|
|
|
return CMICommentsFromLMS;
|
|
}(_common.CMIArray);
|
|
/**
|
|
* Class representing SCORM 2004's cmi.comments_from_learner object
|
|
*/
|
|
|
|
|
|
var CMICommentsFromLearner = /*#__PURE__*/function (_CMIArray4) {
|
|
_inherits(CMICommentsFromLearner, _CMIArray4);
|
|
|
|
var _super6 = _createSuper(CMICommentsFromLearner);
|
|
|
|
/**
|
|
* Constructor for cmi.comments_from_learner Array
|
|
*/
|
|
function CMICommentsFromLearner() {
|
|
_classCallCheck(this, CMICommentsFromLearner);
|
|
|
|
return _super6.call(this, {
|
|
children: scorm2004_constants.comments_children,
|
|
errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,
|
|
errorClass: _exceptions.Scorm2004ValidationError
|
|
});
|
|
}
|
|
|
|
return CMICommentsFromLearner;
|
|
}(_common.CMIArray);
|
|
/**
|
|
* Class for SCORM 2004's cmi.interaction.n object
|
|
*/
|
|
|
|
|
|
var _id = /*#__PURE__*/new WeakMap();
|
|
|
|
var _type = /*#__PURE__*/new WeakMap();
|
|
|
|
var _timestamp = /*#__PURE__*/new WeakMap();
|
|
|
|
var _weighting = /*#__PURE__*/new WeakMap();
|
|
|
|
var _learner_response = /*#__PURE__*/new WeakMap();
|
|
|
|
var _result = /*#__PURE__*/new WeakMap();
|
|
|
|
var _latency = /*#__PURE__*/new WeakMap();
|
|
|
|
var _description = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI3) {
|
|
_inherits(CMIInteractionsObject, _BaseCMI3);
|
|
|
|
var _super7 = _createSuper(CMIInteractionsObject);
|
|
|
|
/**
|
|
* Constructor for cmi.interaction.n
|
|
*/
|
|
function CMIInteractionsObject() {
|
|
var _this3;
|
|
|
|
_classCallCheck(this, CMIInteractionsObject);
|
|
|
|
_this3 = _super7.call(this);
|
|
|
|
_id.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_type.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_timestamp.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_weighting.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_learner_response.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_result.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_latency.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_description.set(_assertThisInitialized(_this3), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_this3.objectives = new _common.CMIArray({
|
|
errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,
|
|
errorClass: _exceptions.Scorm2004ValidationError,
|
|
children: scorm2004_constants.objectives_children
|
|
});
|
|
_this3.correct_responses = new _common.CMIArray({
|
|
errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,
|
|
errorClass: _exceptions.Scorm2004ValidationError,
|
|
children: scorm2004_constants.correct_responses_children
|
|
});
|
|
return _this3;
|
|
}
|
|
/**
|
|
* Called when the API has been initialized after the CMI has been created
|
|
*/
|
|
|
|
|
|
_createClass(CMIInteractionsObject, [{
|
|
key: "initialize",
|
|
value: function initialize() {
|
|
var _this$objectives2, _this$correct_respons;
|
|
|
|
_get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this);
|
|
|
|
(_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize();
|
|
(_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize();
|
|
}
|
|
/**
|
|
* Getter for #id
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "id",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _id);
|
|
}
|
|
/**
|
|
* Setter for #id
|
|
* @param {string} id
|
|
*/
|
|
,
|
|
set: function set(id) {
|
|
if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {
|
|
_classPrivateFieldSet(this, _id, id);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #type
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "type",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _type);
|
|
}
|
|
/**
|
|
* Setter for #type
|
|
* @param {string} type
|
|
*/
|
|
,
|
|
set: function set(type) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {
|
|
_classPrivateFieldSet(this, _type, type);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #timestamp
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "timestamp",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _timestamp);
|
|
}
|
|
/**
|
|
* Setter for #timestamp
|
|
* @param {string} timestamp
|
|
*/
|
|
,
|
|
set: function set(timestamp) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {
|
|
_classPrivateFieldSet(this, _timestamp, timestamp);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #weighting
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "weighting",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _weighting);
|
|
}
|
|
/**
|
|
* Setter for #weighting
|
|
* @param {string} weighting
|
|
*/
|
|
,
|
|
set: function set(weighting) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {
|
|
_classPrivateFieldSet(this, _weighting, weighting);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #learner_response
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "learner_response",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _learner_response);
|
|
}
|
|
/**
|
|
* Setter for #learner_response. Does type validation to make sure response
|
|
* matches SCORM 2004's spec
|
|
* @param {string} learner_response
|
|
*/
|
|
,
|
|
set: function set(learner_response) {
|
|
if (this.initialized && (_classPrivateFieldGet(this, _type) === '' || _classPrivateFieldGet(this, _id) === '')) {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
var nodes = [];
|
|
var response_type = learner_responses[this.type];
|
|
|
|
if (response_type) {
|
|
if (response_type !== null && response_type !== void 0 && response_type.delimiter) {
|
|
nodes = learner_response.split(response_type.delimiter);
|
|
} else {
|
|
nodes[0] = learner_response;
|
|
}
|
|
|
|
if (nodes.length > 0 && nodes.length <= response_type.max) {
|
|
var formatRegex = new RegExp(response_type.format);
|
|
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
if (response_type !== null && response_type !== void 0 && response_type.delimiter2) {
|
|
var values = nodes[i].split(response_type.delimiter2);
|
|
|
|
if (values.length === 2) {
|
|
if (!values[0].match(formatRegex)) {
|
|
throwTypeMismatchError();
|
|
} else {
|
|
if (!values[1].match(new RegExp(response_type.format2))) {
|
|
throwTypeMismatchError();
|
|
}
|
|
}
|
|
} else {
|
|
throwTypeMismatchError();
|
|
}
|
|
} else {
|
|
if (!nodes[i].match(formatRegex)) {
|
|
throwTypeMismatchError();
|
|
} else {
|
|
if (nodes[i] !== '' && response_type.unique) {
|
|
for (var j = 0; j < i; j++) {
|
|
if (nodes[i] === nodes[j]) {
|
|
throwTypeMismatchError();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
throwGeneralSetError();
|
|
}
|
|
|
|
_classPrivateFieldSet(this, _learner_response, learner_response);
|
|
} else {
|
|
throwTypeMismatchError();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #result
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "result",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _result);
|
|
}
|
|
/**
|
|
* Setter for #result
|
|
* @param {string} result
|
|
*/
|
|
,
|
|
set: function set(result) {
|
|
if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) {
|
|
_classPrivateFieldSet(this, _result, result);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #latency
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "latency",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _latency);
|
|
}
|
|
/**
|
|
* Setter for #latency
|
|
* @param {string} latency
|
|
*/
|
|
,
|
|
set: function set(latency) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {
|
|
_classPrivateFieldSet(this, _latency, latency);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #description
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "description",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _description);
|
|
}
|
|
/**
|
|
* Setter for #description
|
|
* @param {string} description
|
|
*/
|
|
,
|
|
set: function set(description) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) {
|
|
_classPrivateFieldSet(this, _description, description);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for cmi.interactions.n
|
|
*
|
|
* @return {
|
|
* {
|
|
* id: string,
|
|
* type: string,
|
|
* objectives: CMIArray,
|
|
* timestamp: string,
|
|
* correct_responses: CMIArray,
|
|
* weighting: string,
|
|
* learner_response: string,
|
|
* result: string,
|
|
* latency: string,
|
|
* description: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'id': this.id,
|
|
'type': this.type,
|
|
'objectives': this.objectives,
|
|
'timestamp': this.timestamp,
|
|
'weighting': this.weighting,
|
|
'learner_response': this.learner_response,
|
|
'result': this.result,
|
|
'latency': this.latency,
|
|
'description': this.description,
|
|
'correct_responses': this.correct_responses
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMIInteractionsObject;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class for SCORM 2004's cmi.objectives.n object
|
|
*/
|
|
|
|
|
|
exports.CMIInteractionsObject = CMIInteractionsObject;
|
|
|
|
var _id2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _success_status2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _completion_status2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _progress_measure2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _description2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI4) {
|
|
_inherits(CMIObjectivesObject, _BaseCMI4);
|
|
|
|
var _super8 = _createSuper(CMIObjectivesObject);
|
|
|
|
/**
|
|
* Constructor for cmi.objectives.n
|
|
*/
|
|
function CMIObjectivesObject() {
|
|
var _this4;
|
|
|
|
_classCallCheck(this, CMIObjectivesObject);
|
|
|
|
_this4 = _super8.call(this);
|
|
|
|
_id2.set(_assertThisInitialized(_this4), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_success_status2.set(_assertThisInitialized(_this4), {
|
|
writable: true,
|
|
value: 'unknown'
|
|
});
|
|
|
|
_completion_status2.set(_assertThisInitialized(_this4), {
|
|
writable: true,
|
|
value: 'unknown'
|
|
});
|
|
|
|
_progress_measure2.set(_assertThisInitialized(_this4), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_description2.set(_assertThisInitialized(_this4), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_this4.score = new Scorm2004CMIScore();
|
|
return _this4;
|
|
}
|
|
/**
|
|
* Called when the API has been initialized after the CMI has been created
|
|
*/
|
|
|
|
|
|
_createClass(CMIObjectivesObject, [{
|
|
key: "initialize",
|
|
value: function initialize() {
|
|
var _this$score2;
|
|
|
|
_get(_getPrototypeOf(CMIObjectivesObject.prototype), "initialize", this).call(this);
|
|
|
|
(_this$score2 = this.score) === null || _this$score2 === void 0 ? void 0 : _this$score2.initialize();
|
|
}
|
|
/**
|
|
* Getter for #id
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "id",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _id2);
|
|
}
|
|
/**
|
|
* Setter for #id
|
|
* @param {string} id
|
|
*/
|
|
,
|
|
set: function set(id) {
|
|
if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {
|
|
_classPrivateFieldSet(this, _id2, id);
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #success_status
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "success_status",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _success_status2);
|
|
}
|
|
/**
|
|
* Setter for #success_status
|
|
* @param {string} success_status
|
|
*/
|
|
,
|
|
set: function set(success_status) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id2) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {
|
|
_classPrivateFieldSet(this, _success_status2, success_status);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #completion_status
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "completion_status",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _completion_status2);
|
|
}
|
|
/**
|
|
* Setter for #completion_status
|
|
* @param {string} completion_status
|
|
*/
|
|
,
|
|
set: function set(completion_status) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id2) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {
|
|
_classPrivateFieldSet(this, _completion_status2, completion_status);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #progress_measure
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "progress_measure",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _progress_measure2);
|
|
}
|
|
/**
|
|
* Setter for #progress_measure
|
|
* @param {string} progress_measure
|
|
*/
|
|
,
|
|
set: function set(progress_measure) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id2) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) {
|
|
_classPrivateFieldSet(this, _progress_measure2, progress_measure);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #description
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "description",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _description2);
|
|
}
|
|
/**
|
|
* Setter for #description
|
|
* @param {string} description
|
|
*/
|
|
,
|
|
set: function set(description) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _id2) === '') {
|
|
throwDependencyNotEstablishedError();
|
|
} else {
|
|
if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) {
|
|
_classPrivateFieldSet(this, _description2, description);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for cmi.objectives.n
|
|
*
|
|
* @return {
|
|
* {
|
|
* id: string,
|
|
* success_status: string,
|
|
* completion_status: string,
|
|
* progress_measure: string,
|
|
* description: string,
|
|
* score: Scorm2004CMIScore
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'id': this.id,
|
|
'success_status': this.success_status,
|
|
'completion_status': this.completion_status,
|
|
'progress_measure': this.progress_measure,
|
|
'description': this.description,
|
|
'score': this.score
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMIObjectivesObject;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class for SCORM 2004's cmi *.score object
|
|
*/
|
|
|
|
|
|
exports.CMIObjectivesObject = CMIObjectivesObject;
|
|
|
|
var _scaled = /*#__PURE__*/new WeakMap();
|
|
|
|
var Scorm2004CMIScore = /*#__PURE__*/function (_CMIScore) {
|
|
_inherits(Scorm2004CMIScore, _CMIScore);
|
|
|
|
var _super9 = _createSuper(Scorm2004CMIScore);
|
|
|
|
/**
|
|
* Constructor for cmi *.score
|
|
*/
|
|
function Scorm2004CMIScore() {
|
|
var _this5;
|
|
|
|
_classCallCheck(this, Scorm2004CMIScore);
|
|
|
|
_this5 = _super9.call(this, {
|
|
score_children: scorm2004_constants.score_children,
|
|
max: '',
|
|
invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,
|
|
invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,
|
|
invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,
|
|
decimalRegex: scorm2004_regex.CMIDecimal,
|
|
errorClass: _exceptions.Scorm2004ValidationError
|
|
});
|
|
|
|
_scaled.set(_assertThisInitialized(_this5), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
return _this5;
|
|
}
|
|
/**
|
|
* Getter for #scaled
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
_createClass(Scorm2004CMIScore, [{
|
|
key: "scaled",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _scaled);
|
|
}
|
|
/**
|
|
* Setter for #scaled
|
|
* @param {string} scaled
|
|
*/
|
|
,
|
|
set: function set(scaled) {
|
|
if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) && check2004ValidRange(scaled, scorm2004_regex.scaled_range)) {
|
|
_classPrivateFieldSet(this, _scaled, scaled);
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for cmi *.score
|
|
*
|
|
* @return {
|
|
* {
|
|
* scaled: string,
|
|
* raw: string,
|
|
* min: string,
|
|
* max: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'scaled': this.scaled,
|
|
'raw': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "raw", this),
|
|
'min': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "min", this),
|
|
'max': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "max", this)
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return Scorm2004CMIScore;
|
|
}(_common.CMIScore);
|
|
/**
|
|
* Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object
|
|
*/
|
|
|
|
|
|
var _comment = /*#__PURE__*/new WeakMap();
|
|
|
|
var _location2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _timestamp2 = /*#__PURE__*/new WeakMap();
|
|
|
|
var _readOnlyAfterInit = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMICommentsObject = /*#__PURE__*/function (_BaseCMI5) {
|
|
_inherits(CMICommentsObject, _BaseCMI5);
|
|
|
|
var _super10 = _createSuper(CMICommentsObject);
|
|
|
|
/**
|
|
* Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n
|
|
* @param {boolean} readOnlyAfterInit
|
|
*/
|
|
function CMICommentsObject() {
|
|
var _this6;
|
|
|
|
var readOnlyAfterInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
|
|
_classCallCheck(this, CMICommentsObject);
|
|
|
|
_this6 = _super10.call(this);
|
|
|
|
_comment.set(_assertThisInitialized(_this6), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_location2.set(_assertThisInitialized(_this6), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_timestamp2.set(_assertThisInitialized(_this6), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
_readOnlyAfterInit.set(_assertThisInitialized(_this6), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this6), _comment, '');
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this6), _location2, '');
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this6), _timestamp2, '');
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this6), _readOnlyAfterInit, readOnlyAfterInit);
|
|
|
|
return _this6;
|
|
}
|
|
/**
|
|
* Getter for #comment
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
_createClass(CMICommentsObject, [{
|
|
key: "comment",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _comment);
|
|
}
|
|
/**
|
|
* Setter for #comment
|
|
* @param {string} comment
|
|
*/
|
|
,
|
|
set: function set(comment) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) {
|
|
throwReadOnlyError();
|
|
} else {
|
|
if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000, true)) {
|
|
_classPrivateFieldSet(this, _comment, comment);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #location
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "location",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _location2);
|
|
}
|
|
/**
|
|
* Setter for #location
|
|
* @param {string} location
|
|
*/
|
|
,
|
|
set: function set(location) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) {
|
|
throwReadOnlyError();
|
|
} else {
|
|
if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {
|
|
_classPrivateFieldSet(this, _location2, location);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Getter for #timestamp
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "timestamp",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _timestamp2);
|
|
}
|
|
/**
|
|
* Setter for #timestamp
|
|
* @param {string} timestamp
|
|
*/
|
|
,
|
|
set: function set(timestamp) {
|
|
if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) {
|
|
throwReadOnlyError();
|
|
} else {
|
|
if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {
|
|
_classPrivateFieldSet(this, _timestamp2, timestamp);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for cmi.comments_from_learner.n object
|
|
* @return {
|
|
* {
|
|
* comment: string,
|
|
* location: string,
|
|
* timestamp: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'comment': this.comment,
|
|
'location': this.location,
|
|
'timestamp': this.timestamp
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMICommentsObject;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class representing SCORM 2004's cmi.interactions.n.objectives.n object
|
|
*/
|
|
|
|
|
|
exports.CMICommentsObject = CMICommentsObject;
|
|
|
|
var _id3 = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI6) {
|
|
_inherits(CMIInteractionsObjectivesObject, _BaseCMI6);
|
|
|
|
var _super11 = _createSuper(CMIInteractionsObjectivesObject);
|
|
|
|
/**
|
|
* Constructor for cmi.interactions.n.objectives.n
|
|
*/
|
|
function CMIInteractionsObjectivesObject() {
|
|
var _this7;
|
|
|
|
_classCallCheck(this, CMIInteractionsObjectivesObject);
|
|
|
|
_this7 = _super11.call(this);
|
|
|
|
_id3.set(_assertThisInitialized(_this7), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
return _this7;
|
|
}
|
|
/**
|
|
* Getter for #id
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
_createClass(CMIInteractionsObjectivesObject, [{
|
|
key: "id",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _id3);
|
|
}
|
|
/**
|
|
* Setter for #id
|
|
* @param {string} id
|
|
*/
|
|
,
|
|
set: function set(id) {
|
|
if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {
|
|
_classPrivateFieldSet(this, _id3, id);
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for cmi.interactions.n.objectives.n
|
|
* @return {
|
|
* {
|
|
* id: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'id': this.id
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMIInteractionsObjectivesObject;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object
|
|
*/
|
|
|
|
|
|
exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject;
|
|
|
|
var _pattern = /*#__PURE__*/new WeakMap();
|
|
|
|
var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI7) {
|
|
_inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI7);
|
|
|
|
var _super12 = _createSuper(CMIInteractionsCorrectResponsesObject);
|
|
|
|
/**
|
|
* Constructor for cmi.interactions.n.correct_responses.n
|
|
*/
|
|
function CMIInteractionsCorrectResponsesObject() {
|
|
var _this8;
|
|
|
|
_classCallCheck(this, CMIInteractionsCorrectResponsesObject);
|
|
|
|
_this8 = _super12.call(this);
|
|
|
|
_pattern.set(_assertThisInitialized(_this8), {
|
|
writable: true,
|
|
value: ''
|
|
});
|
|
|
|
return _this8;
|
|
}
|
|
/**
|
|
* Getter for #pattern
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
_createClass(CMIInteractionsCorrectResponsesObject, [{
|
|
key: "pattern",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _pattern);
|
|
}
|
|
/**
|
|
* Setter for #pattern
|
|
* @param {string} pattern
|
|
*/
|
|
,
|
|
set: function set(pattern) {
|
|
if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) {
|
|
_classPrivateFieldSet(this, _pattern, pattern);
|
|
}
|
|
}
|
|
/**
|
|
* toJSON cmi.interactions.n.correct_responses.n object
|
|
* @return {
|
|
* {
|
|
* pattern: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'pattern': this.pattern
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return CMIInteractionsCorrectResponsesObject;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class representing SCORM 2004's adl object
|
|
*/
|
|
|
|
|
|
exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject;
|
|
|
|
var ADL = /*#__PURE__*/function (_BaseCMI8) {
|
|
_inherits(ADL, _BaseCMI8);
|
|
|
|
var _super13 = _createSuper(ADL);
|
|
|
|
/**
|
|
* Constructor for adl
|
|
*/
|
|
function ADL() {
|
|
var _this9;
|
|
|
|
_classCallCheck(this, ADL);
|
|
|
|
_this9 = _super13.call(this);
|
|
_this9.nav = new ADLNav();
|
|
return _this9;
|
|
}
|
|
/**
|
|
* Called when the API has been initialized after the CMI has been created
|
|
*/
|
|
|
|
|
|
_createClass(ADL, [{
|
|
key: "initialize",
|
|
value: function initialize() {
|
|
var _this$nav;
|
|
|
|
_get(_getPrototypeOf(ADL.prototype), "initialize", this).call(this);
|
|
|
|
(_this$nav = this.nav) === null || _this$nav === void 0 ? void 0 : _this$nav.initialize();
|
|
}
|
|
/**
|
|
* toJSON for adl
|
|
* @return {
|
|
* {
|
|
* nav: {
|
|
* request: string
|
|
* }
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'nav': this.nav
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return ADL;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class representing SCORM 2004's adl.nav object
|
|
*/
|
|
|
|
|
|
exports.ADL = ADL;
|
|
|
|
var _request = /*#__PURE__*/new WeakMap();
|
|
|
|
var ADLNav = /*#__PURE__*/function (_BaseCMI9) {
|
|
_inherits(ADLNav, _BaseCMI9);
|
|
|
|
var _super14 = _createSuper(ADLNav);
|
|
|
|
/**
|
|
* Constructor for adl.nav
|
|
*/
|
|
function ADLNav() {
|
|
var _this10;
|
|
|
|
_classCallCheck(this, ADLNav);
|
|
|
|
_this10 = _super14.call(this);
|
|
|
|
_request.set(_assertThisInitialized(_this10), {
|
|
writable: true,
|
|
value: '_none_'
|
|
});
|
|
|
|
_this10.request_valid = new ADLNavRequestValid();
|
|
return _this10;
|
|
}
|
|
/**
|
|
* Called when the API has been initialized after the CMI has been created
|
|
*/
|
|
|
|
|
|
_createClass(ADLNav, [{
|
|
key: "initialize",
|
|
value: function initialize() {
|
|
var _this$request_valid;
|
|
|
|
_get(_getPrototypeOf(ADLNav.prototype), "initialize", this).call(this);
|
|
|
|
(_this$request_valid = this.request_valid) === null || _this$request_valid === void 0 ? void 0 : _this$request_valid.initialize();
|
|
}
|
|
/**
|
|
* Getter for #request
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "request",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _request);
|
|
}
|
|
/**
|
|
* Setter for #request
|
|
* @param {string} request
|
|
*/
|
|
,
|
|
set: function set(request) {
|
|
if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) {
|
|
_classPrivateFieldSet(this, _request, request);
|
|
}
|
|
}
|
|
/**
|
|
* toJSON for adl.nav
|
|
*
|
|
* @return {
|
|
* {
|
|
* request: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'request': this.request
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return ADLNav;
|
|
}(_common.BaseCMI);
|
|
/**
|
|
* Class representing SCORM 2004's adl.nav.request_valid object
|
|
*/
|
|
|
|
|
|
var _continue = /*#__PURE__*/new WeakMap();
|
|
|
|
var _previous = /*#__PURE__*/new WeakMap();
|
|
|
|
var ADLNavRequestValid = /*#__PURE__*/function (_BaseCMI10) {
|
|
_inherits(ADLNavRequestValid, _BaseCMI10);
|
|
|
|
var _super15 = _createSuper(ADLNavRequestValid);
|
|
|
|
/**
|
|
* Constructor for adl.nav.request_valid
|
|
*/
|
|
function ADLNavRequestValid() {
|
|
var _this11;
|
|
|
|
_classCallCheck(this, ADLNavRequestValid);
|
|
|
|
_this11 = _super15.call(this);
|
|
|
|
_continue.set(_assertThisInitialized(_this11), {
|
|
writable: true,
|
|
value: 'unknown'
|
|
});
|
|
|
|
_previous.set(_assertThisInitialized(_this11), {
|
|
writable: true,
|
|
value: 'unknown'
|
|
});
|
|
|
|
_defineProperty(_assertThisInitialized(_this11), "choice", /*#__PURE__*/function () {
|
|
function _class2() {
|
|
_classCallCheck(this, _class2);
|
|
|
|
_defineProperty(this, "_isTargetValid", function (_target) {
|
|
return 'unknown';
|
|
});
|
|
}
|
|
|
|
return _class2;
|
|
}());
|
|
|
|
_defineProperty(_assertThisInitialized(_this11), "jump", /*#__PURE__*/function () {
|
|
function _class4() {
|
|
_classCallCheck(this, _class4);
|
|
|
|
_defineProperty(this, "_isTargetValid", function (_target) {
|
|
return 'unknown';
|
|
});
|
|
}
|
|
|
|
return _class4;
|
|
}());
|
|
|
|
return _this11;
|
|
}
|
|
/**
|
|
* Getter for #continue
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
_createClass(ADLNavRequestValid, [{
|
|
key: "continue",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _continue);
|
|
}
|
|
/**
|
|
* Setter for #continue. Just throws an error.
|
|
* @param {*} _
|
|
*/
|
|
,
|
|
set: function set(_) {
|
|
throwReadOnlyError();
|
|
}
|
|
/**
|
|
* Getter for #previous
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "previous",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _previous);
|
|
}
|
|
/**
|
|
* Setter for #previous. Just throws an error.
|
|
* @param {*} _
|
|
*/
|
|
,
|
|
set: function set(_) {
|
|
throwReadOnlyError();
|
|
}
|
|
/**
|
|
* toJSON for adl.nav.request_valid
|
|
*
|
|
* @return {
|
|
* {
|
|
* previous: string,
|
|
* continue: string
|
|
* }
|
|
* }
|
|
*/
|
|
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
this.jsonString = true;
|
|
var result = {
|
|
'previous': this.previous,
|
|
'continue': this["continue"]
|
|
};
|
|
delete this.jsonString;
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return ADLNavRequestValid;
|
|
}(_common.BaseCMI);
|
|
|
|
},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":9,"../constants/response_constants":10,"../exceptions":11,"../utilities":13,"./common":4}],6:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var global = {
|
|
SCORM_TRUE: 'true',
|
|
SCORM_FALSE: 'false',
|
|
STATE_NOT_INITIALIZED: 0,
|
|
STATE_INITIALIZED: 1,
|
|
STATE_TERMINATED: 2,
|
|
LOG_LEVEL_DEBUG: 1,
|
|
LOG_LEVEL_INFO: 2,
|
|
LOG_LEVEL_WARNING: 3,
|
|
LOG_LEVEL_ERROR: 4,
|
|
LOG_LEVEL_NONE: 5
|
|
};
|
|
var scorm12 = {
|
|
// Children lists
|
|
cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',
|
|
core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',
|
|
score_children: 'raw,min,max',
|
|
comments_children: 'content,location,time',
|
|
objectives_children: 'id,score,status',
|
|
correct_responses_children: 'pattern',
|
|
student_data_children: 'mastery_score,max_time_allowed,time_limit_action',
|
|
student_preference_children: 'audio,language,speed,text',
|
|
interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',
|
|
error_descriptions: {
|
|
'101': {
|
|
basicMessage: 'General Exception',
|
|
detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information'
|
|
},
|
|
'201': {
|
|
basicMessage: 'Invalid argument error',
|
|
detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.'
|
|
},
|
|
'202': {
|
|
basicMessage: 'Element cannot have children',
|
|
detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_children" for a data model element that does not support the "_children" suffix.'
|
|
},
|
|
'203': {
|
|
basicMessage: 'Element not an array - cannot have count',
|
|
detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_count" for a data model element that does not support the "_count" suffix.'
|
|
},
|
|
'301': {
|
|
basicMessage: 'Not initialized',
|
|
detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.'
|
|
},
|
|
'401': {
|
|
basicMessage: 'Not implemented error',
|
|
detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.'
|
|
},
|
|
'402': {
|
|
basicMessage: 'Invalid set value, element is a keyword',
|
|
detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in "_children" and "_count").'
|
|
},
|
|
'403': {
|
|
basicMessage: 'Element is read only',
|
|
detailMessage: 'LMSSetValue was called with a data model element that can only be read.'
|
|
},
|
|
'404': {
|
|
basicMessage: 'Element is write only',
|
|
detailMessage: 'LMSGetValue was called on a data model element that can only be written to.'
|
|
},
|
|
'405': {
|
|
basicMessage: 'Incorrect Data Type',
|
|
detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.'
|
|
},
|
|
'407': {
|
|
basicMessage: 'Element Value Out Of Range',
|
|
detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.'
|
|
},
|
|
'408': {
|
|
basicMessage: 'Data Model Dependency Not Established',
|
|
detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.'
|
|
}
|
|
}
|
|
};
|
|
|
|
var aicc = _objectSpread(_objectSpread({}, scorm12), {
|
|
cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',
|
|
student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',
|
|
student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',
|
|
student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',
|
|
tries_children: 'time,status,score',
|
|
attempt_records_children: 'score,lesson_status',
|
|
paths_children: 'location_id,date,time,status,why_left,time_in_element'
|
|
});
|
|
|
|
var scorm2004 = {
|
|
// Children lists
|
|
cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',
|
|
comments_children: 'comment,timestamp,location',
|
|
score_children: 'max,raw,scaled,min',
|
|
objectives_children: 'progress_measure,completion_status,success_status,description,score,id',
|
|
correct_responses_children: 'pattern',
|
|
student_data_children: 'mastery_score,max_time_allowed,time_limit_action',
|
|
student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',
|
|
interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',
|
|
error_descriptions: {
|
|
'0': {
|
|
basicMessage: 'No Error',
|
|
detailMessage: 'No error occurred, the previous API call was successful.'
|
|
},
|
|
'101': {
|
|
basicMessage: 'General Exception',
|
|
detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.'
|
|
},
|
|
'102': {
|
|
basicMessage: 'General Initialization Failure',
|
|
detailMessage: 'Call to Initialize failed for an unknown reason.'
|
|
},
|
|
'103': {
|
|
basicMessage: 'Already Initialized',
|
|
detailMessage: 'Call to Initialize failed because Initialize was already called.'
|
|
},
|
|
'104': {
|
|
basicMessage: 'Content Instance Terminated',
|
|
detailMessage: 'Call to Initialize failed because Terminate was already called.'
|
|
},
|
|
'111': {
|
|
basicMessage: 'General Termination Failure',
|
|
detailMessage: 'Call to Terminate failed for an unknown reason.'
|
|
},
|
|
'112': {
|
|
basicMessage: 'Termination Before Initialization',
|
|
detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.'
|
|
},
|
|
'113': {
|
|
basicMessage: 'Termination After Termination',
|
|
detailMessage: 'Call to Terminate failed because Terminate was already called.'
|
|
},
|
|
'122': {
|
|
basicMessage: 'Retrieve Data Before Initialization',
|
|
detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.'
|
|
},
|
|
'123': {
|
|
basicMessage: 'Retrieve Data After Termination',
|
|
detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.'
|
|
},
|
|
'132': {
|
|
basicMessage: 'Store Data Before Initialization',
|
|
detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.'
|
|
},
|
|
'133': {
|
|
basicMessage: 'Store Data After Termination',
|
|
detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.'
|
|
},
|
|
'142': {
|
|
basicMessage: 'Commit Before Initialization',
|
|
detailMessage: 'Call to Commit failed because it was made before the call to Initialize.'
|
|
},
|
|
'143': {
|
|
basicMessage: 'Commit After Termination',
|
|
detailMessage: 'Call to Commit failed because it was made after the call to Terminate.'
|
|
},
|
|
'201': {
|
|
basicMessage: 'General Argument Error',
|
|
detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.'
|
|
},
|
|
'301': {
|
|
basicMessage: 'General Get Failure',
|
|
detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.'
|
|
},
|
|
'351': {
|
|
basicMessage: 'General Set Failure',
|
|
detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.'
|
|
},
|
|
'391': {
|
|
basicMessage: 'General Commit Failure',
|
|
detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.'
|
|
},
|
|
'401': {
|
|
basicMessage: 'Undefined Data Model Element',
|
|
detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.'
|
|
},
|
|
'402': {
|
|
basicMessage: 'Unimplemented Data Model Element',
|
|
detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.'
|
|
},
|
|
'403': {
|
|
basicMessage: 'Data Model Element Value Not Initialized',
|
|
detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.'
|
|
},
|
|
'404': {
|
|
basicMessage: 'Data Model Element Is Read Only',
|
|
detailMessage: 'SetValue was called with a data model element that can only be read.'
|
|
},
|
|
'405': {
|
|
basicMessage: 'Data Model Element Is Write Only',
|
|
detailMessage: 'GetValue was called on a data model element that can only be written to.'
|
|
},
|
|
'406': {
|
|
basicMessage: 'Data Model Element Type Mismatch',
|
|
detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.'
|
|
},
|
|
'407': {
|
|
basicMessage: 'Data Model Element Value Out Of Range',
|
|
detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.'
|
|
},
|
|
'408': {
|
|
basicMessage: 'Data Model Dependency Not Established',
|
|
detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.'
|
|
}
|
|
}
|
|
};
|
|
var APIConstants = {
|
|
global: global,
|
|
scorm12: scorm12,
|
|
aicc: aicc,
|
|
scorm2004: scorm2004
|
|
};
|
|
var _default = APIConstants;
|
|
exports["default"] = _default;
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var global = {
|
|
GENERAL: 101,
|
|
INITIALIZATION_FAILED: 101,
|
|
INITIALIZED: 101,
|
|
TERMINATED: 101,
|
|
TERMINATION_FAILURE: 101,
|
|
TERMINATION_BEFORE_INIT: 101,
|
|
MULTIPLE_TERMINATION: 101,
|
|
RETRIEVE_BEFORE_INIT: 101,
|
|
RETRIEVE_AFTER_TERM: 101,
|
|
STORE_BEFORE_INIT: 101,
|
|
STORE_AFTER_TERM: 101,
|
|
COMMIT_BEFORE_INIT: 101,
|
|
COMMIT_AFTER_TERM: 101,
|
|
ARGUMENT_ERROR: 101,
|
|
CHILDREN_ERROR: 101,
|
|
COUNT_ERROR: 101,
|
|
GENERAL_GET_FAILURE: 101,
|
|
GENERAL_SET_FAILURE: 101,
|
|
GENERAL_COMMIT_FAILURE: 101,
|
|
UNDEFINED_DATA_MODEL: 101,
|
|
UNIMPLEMENTED_ELEMENT: 101,
|
|
VALUE_NOT_INITIALIZED: 101,
|
|
INVALID_SET_VALUE: 101,
|
|
READ_ONLY_ELEMENT: 101,
|
|
WRITE_ONLY_ELEMENT: 101,
|
|
TYPE_MISMATCH: 101,
|
|
VALUE_OUT_OF_RANGE: 101,
|
|
DEPENDENCY_NOT_ESTABLISHED: 101
|
|
};
|
|
|
|
var scorm12 = _objectSpread(_objectSpread({}, global), {
|
|
RETRIEVE_BEFORE_INIT: 301,
|
|
STORE_BEFORE_INIT: 301,
|
|
COMMIT_BEFORE_INIT: 301,
|
|
ARGUMENT_ERROR: 201,
|
|
CHILDREN_ERROR: 202,
|
|
COUNT_ERROR: 203,
|
|
UNDEFINED_DATA_MODEL: 401,
|
|
UNIMPLEMENTED_ELEMENT: 401,
|
|
VALUE_NOT_INITIALIZED: 301,
|
|
INVALID_SET_VALUE: 402,
|
|
READ_ONLY_ELEMENT: 403,
|
|
WRITE_ONLY_ELEMENT: 404,
|
|
TYPE_MISMATCH: 405,
|
|
VALUE_OUT_OF_RANGE: 407,
|
|
DEPENDENCY_NOT_ESTABLISHED: 408
|
|
});
|
|
|
|
var scorm2004 = _objectSpread(_objectSpread({}, global), {
|
|
INITIALIZATION_FAILED: 102,
|
|
INITIALIZED: 103,
|
|
TERMINATED: 104,
|
|
TERMINATION_FAILURE: 111,
|
|
TERMINATION_BEFORE_INIT: 112,
|
|
MULTIPLE_TERMINATIONS: 113,
|
|
RETRIEVE_BEFORE_INIT: 122,
|
|
RETRIEVE_AFTER_TERM: 123,
|
|
STORE_BEFORE_INIT: 132,
|
|
STORE_AFTER_TERM: 133,
|
|
COMMIT_BEFORE_INIT: 142,
|
|
COMMIT_AFTER_TERM: 143,
|
|
ARGUMENT_ERROR: 201,
|
|
GENERAL_GET_FAILURE: 301,
|
|
GENERAL_SET_FAILURE: 351,
|
|
GENERAL_COMMIT_FAILURE: 391,
|
|
UNDEFINED_DATA_MODEL: 401,
|
|
UNIMPLEMENTED_ELEMENT: 402,
|
|
VALUE_NOT_INITIALIZED: 403,
|
|
READ_ONLY_ELEMENT: 404,
|
|
WRITE_ONLY_ELEMENT: 405,
|
|
TYPE_MISMATCH: 406,
|
|
VALUE_OUT_OF_RANGE: 407,
|
|
DEPENDENCY_NOT_ESTABLISHED: 408
|
|
});
|
|
|
|
var ErrorCodes = {
|
|
scorm12: scorm12,
|
|
scorm2004: scorm2004
|
|
};
|
|
var _default = ErrorCodes;
|
|
exports["default"] = _default;
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
var ValidLanguages = {
|
|
'aa': 'aa',
|
|
'ab': 'ab',
|
|
'ae': 'ae',
|
|
'af': 'af',
|
|
'ak': 'ak',
|
|
'am': 'am',
|
|
'an': 'an',
|
|
'ar': 'ar',
|
|
'as': 'as',
|
|
'av': 'av',
|
|
'ay': 'ay',
|
|
'az': 'az',
|
|
'ba': 'ba',
|
|
'be': 'be',
|
|
'bg': 'bg',
|
|
'bh': 'bh',
|
|
'bi': 'bi',
|
|
'bm': 'bm',
|
|
'bn': 'bn',
|
|
'bo': 'bo',
|
|
'br': 'br',
|
|
'bs': 'bs',
|
|
'ca': 'ca',
|
|
'ce': 'ce',
|
|
'ch': 'ch',
|
|
'co': 'co',
|
|
'cr': 'cr',
|
|
'cs': 'cs',
|
|
'cu': 'cu',
|
|
'cv': 'cv',
|
|
'cy': 'cy',
|
|
'da': 'da',
|
|
'de': 'de',
|
|
'dv': 'dv',
|
|
'dz': 'dz',
|
|
'ee': 'ee',
|
|
'el': 'el',
|
|
'en': 'en',
|
|
'eo': 'eo',
|
|
'es': 'es',
|
|
'et': 'et',
|
|
'eu': 'eu',
|
|
'fa': 'fa',
|
|
'ff': 'ff',
|
|
'fi': 'fi',
|
|
'fj': 'fj',
|
|
'fo': 'fo',
|
|
'fr': 'fr',
|
|
'fy': 'fy',
|
|
'ga': 'ga',
|
|
'gd': 'gd',
|
|
'gl': 'gl',
|
|
'gn': 'gn',
|
|
'gu': 'gu',
|
|
'gv': 'gv',
|
|
'ha': 'ha',
|
|
'he': 'he',
|
|
'hi': 'hi',
|
|
'ho': 'ho',
|
|
'hr': 'hr',
|
|
'ht': 'ht',
|
|
'hu': 'hu',
|
|
'hy': 'hy',
|
|
'hz': 'hz',
|
|
'ia': 'ia',
|
|
'id': 'id',
|
|
'ie': 'ie',
|
|
'ig': 'ig',
|
|
'ii': 'ii',
|
|
'ik': 'ik',
|
|
'io': 'io',
|
|
'is': 'is',
|
|
'it': 'it',
|
|
'iu': 'iu',
|
|
'ja': 'ja',
|
|
'jv': 'jv',
|
|
'ka': 'ka',
|
|
'kg': 'kg',
|
|
'ki': 'ki',
|
|
'kj': 'kj',
|
|
'kk': 'kk',
|
|
'kl': 'kl',
|
|
'km': 'km',
|
|
'kn': 'kn',
|
|
'ko': 'ko',
|
|
'kr': 'kr',
|
|
'ks': 'ks',
|
|
'ku': 'ku',
|
|
'kv': 'kv',
|
|
'kw': 'kw',
|
|
'ky': 'ky',
|
|
'la': 'la',
|
|
'lb': 'lb',
|
|
'lg': 'lg',
|
|
'li': 'li',
|
|
'ln': 'ln',
|
|
'lo': 'lo',
|
|
'lt': 'lt',
|
|
'lu': 'lu',
|
|
'lv': 'lv',
|
|
'mg': 'mg',
|
|
'mh': 'mh',
|
|
'mi': 'mi',
|
|
'mk': 'mk',
|
|
'ml': 'ml',
|
|
'mn': 'mn',
|
|
'mo': 'mo',
|
|
'mr': 'mr',
|
|
'ms': 'ms',
|
|
'mt': 'mt',
|
|
'my': 'my',
|
|
'na': 'na',
|
|
'nb': 'nb',
|
|
'nd': 'nd',
|
|
'ne': 'ne',
|
|
'ng': 'ng',
|
|
'nl': 'nl',
|
|
'nn': 'nn',
|
|
'no': 'no',
|
|
'nr': 'nr',
|
|
'nv': 'nv',
|
|
'ny': 'ny',
|
|
'oc': 'oc',
|
|
'oj': 'oj',
|
|
'om': 'om',
|
|
'or': 'or',
|
|
'os': 'os',
|
|
'pa': 'pa',
|
|
'pi': 'pi',
|
|
'pl': 'pl',
|
|
'ps': 'ps',
|
|
'pt': 'pt',
|
|
'qu': 'qu',
|
|
'rm': 'rm',
|
|
'rn': 'rn',
|
|
'ro': 'ro',
|
|
'ru': 'ru',
|
|
'rw': 'rw',
|
|
'sa': 'sa',
|
|
'sc': 'sc',
|
|
'sd': 'sd',
|
|
'se': 'se',
|
|
'sg': 'sg',
|
|
'sh': 'sh',
|
|
'si': 'si',
|
|
'sk': 'sk',
|
|
'sl': 'sl',
|
|
'sm': 'sm',
|
|
'sn': 'sn',
|
|
'so': 'so',
|
|
'sq': 'sq',
|
|
'sr': 'sr',
|
|
'ss': 'ss',
|
|
'st': 'st',
|
|
'su': 'su',
|
|
'sv': 'sv',
|
|
'sw': 'sw',
|
|
'ta': 'ta',
|
|
'te': 'te',
|
|
'tg': 'tg',
|
|
'th': 'th',
|
|
'ti': 'ti',
|
|
'tk': 'tk',
|
|
'tl': 'tl',
|
|
'tn': 'tn',
|
|
'to': 'to',
|
|
'tr': 'tr',
|
|
'ts': 'ts',
|
|
'tt': 'tt',
|
|
'tw': 'tw',
|
|
'ty': 'ty',
|
|
'ug': 'ug',
|
|
'uk': 'uk',
|
|
'ur': 'ur',
|
|
'uz': 'uz',
|
|
've': 've',
|
|
'vi': 'vi',
|
|
'vo': 'vo',
|
|
'wa': 'wa',
|
|
'wo': 'wo',
|
|
'xh': 'xh',
|
|
'yi': 'yi',
|
|
'yo': 'yo',
|
|
'za': 'za',
|
|
'zh': 'zh',
|
|
'zu': 'zu',
|
|
'aar': 'aar',
|
|
'abk': 'abk',
|
|
'ave': 'ave',
|
|
'afr': 'afr',
|
|
'aka': 'aka',
|
|
'amh': 'amh',
|
|
'arg': 'arg',
|
|
'ara': 'ara',
|
|
'asm': 'asm',
|
|
'ava': 'ava',
|
|
'aym': 'aym',
|
|
'aze': 'aze',
|
|
'bak': 'bak',
|
|
'bel': 'bel',
|
|
'bul': 'bul',
|
|
'bih': 'bih',
|
|
'bis': 'bis',
|
|
'bam': 'bam',
|
|
'ben': 'ben',
|
|
'tib': 'tib',
|
|
'bod': 'bod',
|
|
'bre': 'bre',
|
|
'bos': 'bos',
|
|
'cat': 'cat',
|
|
'che': 'che',
|
|
'cha': 'cha',
|
|
'cos': 'cos',
|
|
'cre': 'cre',
|
|
'cze': 'cze',
|
|
'ces': 'ces',
|
|
'chu': 'chu',
|
|
'chv': 'chv',
|
|
'wel': 'wel',
|
|
'cym': 'cym',
|
|
'dan': 'dan',
|
|
'ger': 'ger',
|
|
'deu': 'deu',
|
|
'div': 'div',
|
|
'dzo': 'dzo',
|
|
'ewe': 'ewe',
|
|
'gre': 'gre',
|
|
'ell': 'ell',
|
|
'eng': 'eng',
|
|
'epo': 'epo',
|
|
'spa': 'spa',
|
|
'est': 'est',
|
|
'baq': 'baq',
|
|
'eus': 'eus',
|
|
'per': 'per',
|
|
'fas': 'fas',
|
|
'ful': 'ful',
|
|
'fin': 'fin',
|
|
'fij': 'fij',
|
|
'fao': 'fao',
|
|
'fre': 'fre',
|
|
'fra': 'fra',
|
|
'fry': 'fry',
|
|
'gle': 'gle',
|
|
'gla': 'gla',
|
|
'glg': 'glg',
|
|
'grn': 'grn',
|
|
'guj': 'guj',
|
|
'glv': 'glv',
|
|
'hau': 'hau',
|
|
'heb': 'heb',
|
|
'hin': 'hin',
|
|
'hmo': 'hmo',
|
|
'hrv': 'hrv',
|
|
'hat': 'hat',
|
|
'hun': 'hun',
|
|
'arm': 'arm',
|
|
'hye': 'hye',
|
|
'her': 'her',
|
|
'ina': 'ina',
|
|
'ind': 'ind',
|
|
'ile': 'ile',
|
|
'ibo': 'ibo',
|
|
'iii': 'iii',
|
|
'ipk': 'ipk',
|
|
'ido': 'ido',
|
|
'ice': 'ice',
|
|
'isl': 'isl',
|
|
'ita': 'ita',
|
|
'iku': 'iku',
|
|
'jpn': 'jpn',
|
|
'jav': 'jav',
|
|
'geo': 'geo',
|
|
'kat': 'kat',
|
|
'kon': 'kon',
|
|
'kik': 'kik',
|
|
'kua': 'kua',
|
|
'kaz': 'kaz',
|
|
'kal': 'kal',
|
|
'khm': 'khm',
|
|
'kan': 'kan',
|
|
'kor': 'kor',
|
|
'kau': 'kau',
|
|
'kas': 'kas',
|
|
'kur': 'kur',
|
|
'kom': 'kom',
|
|
'cor': 'cor',
|
|
'kir': 'kir',
|
|
'lat': 'lat',
|
|
'ltz': 'ltz',
|
|
'lug': 'lug',
|
|
'lim': 'lim',
|
|
'lin': 'lin',
|
|
'lao': 'lao',
|
|
'lit': 'lit',
|
|
'lub': 'lub',
|
|
'lav': 'lav',
|
|
'mlg': 'mlg',
|
|
'mah': 'mah',
|
|
'mao': 'mao',
|
|
'mri': 'mri',
|
|
'mac': 'mac',
|
|
'mkd': 'mkd',
|
|
'mal': 'mal',
|
|
'mon': 'mon',
|
|
'mol': 'mol',
|
|
'mar': 'mar',
|
|
'may': 'may',
|
|
'msa': 'msa',
|
|
'mlt': 'mlt',
|
|
'bur': 'bur',
|
|
'mya': 'mya',
|
|
'nau': 'nau',
|
|
'nob': 'nob',
|
|
'nde': 'nde',
|
|
'nep': 'nep',
|
|
'ndo': 'ndo',
|
|
'dut': 'dut',
|
|
'nld': 'nld',
|
|
'nno': 'nno',
|
|
'nor': 'nor',
|
|
'nbl': 'nbl',
|
|
'nav': 'nav',
|
|
'nya': 'nya',
|
|
'oci': 'oci',
|
|
'oji': 'oji',
|
|
'orm': 'orm',
|
|
'ori': 'ori',
|
|
'oss': 'oss',
|
|
'pan': 'pan',
|
|
'pli': 'pli',
|
|
'pol': 'pol',
|
|
'pus': 'pus',
|
|
'por': 'por',
|
|
'que': 'que',
|
|
'roh': 'roh',
|
|
'run': 'run',
|
|
'rum': 'rum',
|
|
'ron': 'ron',
|
|
'rus': 'rus',
|
|
'kin': 'kin',
|
|
'san': 'san',
|
|
'srd': 'srd',
|
|
'snd': 'snd',
|
|
'sme': 'sme',
|
|
'sag': 'sag',
|
|
'slo': 'slo',
|
|
'sin': 'sin',
|
|
'slk': 'slk',
|
|
'slv': 'slv',
|
|
'smo': 'smo',
|
|
'sna': 'sna',
|
|
'som': 'som',
|
|
'alb': 'alb',
|
|
'sqi': 'sqi',
|
|
'srp': 'srp',
|
|
'ssw': 'ssw',
|
|
'sot': 'sot',
|
|
'sun': 'sun',
|
|
'swe': 'swe',
|
|
'swa': 'swa',
|
|
'tam': 'tam',
|
|
'tel': 'tel',
|
|
'tgk': 'tgk',
|
|
'tha': 'tha',
|
|
'tir': 'tir',
|
|
'tuk': 'tuk',
|
|
'tgl': 'tgl',
|
|
'tsn': 'tsn',
|
|
'ton': 'ton',
|
|
'tur': 'tur',
|
|
'tso': 'tso',
|
|
'tat': 'tat',
|
|
'twi': 'twi',
|
|
'tah': 'tah',
|
|
'uig': 'uig',
|
|
'ukr': 'ukr',
|
|
'urd': 'urd',
|
|
'uzb': 'uzb',
|
|
'ven': 'ven',
|
|
'vie': 'vie',
|
|
'vol': 'vol',
|
|
'wln': 'wln',
|
|
'wol': 'wol',
|
|
'xho': 'xho',
|
|
'yid': 'yid',
|
|
'yor': 'yor',
|
|
'zha': 'zha',
|
|
'chi': 'chi',
|
|
'zho': 'zho',
|
|
'zul': 'zul'
|
|
};
|
|
var _default = ValidLanguages;
|
|
exports["default"] = _default;
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var scorm12 = {
|
|
CMIString256: '^.{0,255}$',
|
|
CMIString4096: '^.{0,4096}$',
|
|
CMITime: '^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$',
|
|
// eslint-disable-line
|
|
CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\.[0-9]{1,2})?$',
|
|
// eslint-disable-line
|
|
CMIInteger: '^\\d+$',
|
|
CMISInteger: '^-?([0-9]+)$',
|
|
CMIDecimal: '^-?([0-9]{0,3})(\.[0-9]*)?$',
|
|
// eslint-disable-line
|
|
CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$",
|
|
CMIFeedback: '^.{0,255}$',
|
|
// This must be redefined
|
|
CMIIndex: '[._](\\d+).',
|
|
// Vocabulary Data Type Definition
|
|
CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',
|
|
CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',
|
|
CMIExit: '^(time-out|suspend|logout|)$',
|
|
CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',
|
|
CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\.[0-9]*)?)$',
|
|
// eslint-disable-line
|
|
NAVEvent: '^(previous|continue)$',
|
|
// Data ranges
|
|
score_range: '0#100',
|
|
audio_range: '-1#100',
|
|
speed_range: '-100#100',
|
|
weighting_range: '-100#100',
|
|
text_range: '-1#1'
|
|
};
|
|
|
|
var aicc = _objectSpread(_objectSpread({}, scorm12), {
|
|
CMIIdentifier: '^\\w{1,255}$'
|
|
});
|
|
|
|
var scorm2004 = {
|
|
CMIString200: "^[\\u0000-\\uFFFF]{0,200}$",
|
|
CMIString250: "^[\\u0000-\\uFFFF]{0,250}$",
|
|
CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$",
|
|
CMIString4000: "^[\\u0000-\\uFFFF]{0,4000}$",
|
|
CMIString64000: "^[\\u0000-\\uFFFF]{0,64000}$",
|
|
CMILang: '^([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?$|^$',
|
|
// eslint-disable-line
|
|
CMILangString250: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,250}$)?$',
|
|
// eslint-disable-line
|
|
CMILangcr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\}))(.*?)$',
|
|
// eslint-disable-line
|
|
CMILangString250cr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\})?(.{0,250})?)?$',
|
|
// eslint-disable-line
|
|
CMILangString4000: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,4000}$)?$',
|
|
// eslint-disable-line
|
|
CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',
|
|
CMITimespan: '^P(?:([.,\\d]+)Y)?(?:([.,\\d]+)M)?(?:([.,\\d]+)W)?(?:([.,\\d]+)D)?(?:T?(?:([.,\\d]+)H)?(?:([.,\\d]+)M)?(?:([.,\\d]+)S)?)?$',
|
|
CMIInteger: '^\\d+$',
|
|
CMISInteger: '^-?([0-9]+)$',
|
|
CMIDecimal: '^-?([0-9]{1,5})(\\.[0-9]{1,18})?$',
|
|
CMIIdentifier: '^\\S{1,250}[a-zA-Z0-9]$',
|
|
CMIShortIdentifier: '^[\\w\\.\\-\\_]{1,250}$',
|
|
// eslint-disable-line
|
|
CMILongIdentifier: '^(?:(?!urn:)\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\S{1,4000}|.{1,4000})$',
|
|
// need to re-examine this
|
|
CMIFeedback: '^.*$',
|
|
// This must be redefined
|
|
CMIIndex: '[._](\\d+).',
|
|
CMIIndexStore: '.N(\\d+).',
|
|
// Vocabulary Data Type Definition
|
|
CMICStatus: '^(completed|incomplete|not attempted|unknown)$',
|
|
CMISStatus: '^(passed|failed|unknown)$',
|
|
CMIExit: '^(time-out|suspend|logout|normal)$',
|
|
CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',
|
|
CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$',
|
|
NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\{target=\\S{0,200}[a-zA-Z0-9]\}choice|jump)$',
|
|
// eslint-disable-line
|
|
NAVBoolean: '^(unknown|true|false$)',
|
|
NAVTarget: '^(previous|continue|choice.{target=\\S{0,200}[a-zA-Z0-9]})$',
|
|
// Data ranges
|
|
scaled_range: '-1#1',
|
|
audio_range: '0#*',
|
|
speed_range: '0#*',
|
|
text_range: '-1#1',
|
|
progress_range: '0#1'
|
|
};
|
|
var Regex = {
|
|
aicc: aicc,
|
|
scorm12: scorm12,
|
|
scorm2004: scorm2004
|
|
};
|
|
var _default = Regex;
|
|
exports["default"] = _default;
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = void 0;
|
|
|
|
var _regex = _interopRequireDefault(require("./regex"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
var scorm2004_regex = _regex["default"].scorm2004;
|
|
var learner = {
|
|
'true-false': {
|
|
format: '^true$|^false$',
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false
|
|
},
|
|
'choice': {
|
|
format: scorm2004_regex.CMIShortIdentifier,
|
|
max: 36,
|
|
delimiter: '[,]',
|
|
unique: true
|
|
},
|
|
'fill-in': {
|
|
format: scorm2004_regex.CMILangString250,
|
|
max: 10,
|
|
delimiter: '[,]',
|
|
unique: false
|
|
},
|
|
'long-fill-in': {
|
|
format: scorm2004_regex.CMILangString4000,
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false
|
|
},
|
|
'matching': {
|
|
format: scorm2004_regex.CMIShortIdentifier,
|
|
format2: scorm2004_regex.CMIShortIdentifier,
|
|
max: 36,
|
|
delimiter: '[,]',
|
|
delimiter2: '[.]',
|
|
unique: false
|
|
},
|
|
'performance': {
|
|
format: '^$|' + scorm2004_regex.CMIShortIdentifier,
|
|
format2: scorm2004_regex.CMIDecimal + '|^$|' + scorm2004_regex.CMIShortIdentifier,
|
|
max: 250,
|
|
delimiter: '[,]',
|
|
delimiter2: '[.]',
|
|
unique: false
|
|
},
|
|
'sequencing': {
|
|
format: scorm2004_regex.CMIShortIdentifier,
|
|
max: 36,
|
|
delimiter: '[,]',
|
|
unique: false
|
|
},
|
|
'likert': {
|
|
format: scorm2004_regex.CMIShortIdentifier,
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false
|
|
},
|
|
'numeric': {
|
|
format: scorm2004_regex.CMIDecimal,
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false
|
|
},
|
|
'other': {
|
|
format: scorm2004_regex.CMIString4000,
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false
|
|
}
|
|
};
|
|
var correct = {
|
|
'true-false': {
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: '^true$|^false$',
|
|
limit: 1
|
|
},
|
|
'choice': {
|
|
max: 36,
|
|
delimiter: '[,]',
|
|
unique: true,
|
|
duplicate: false,
|
|
format: scorm2004_regex.CMIShortIdentifier
|
|
},
|
|
'fill-in': {
|
|
max: 10,
|
|
delimiter: '[,]',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: scorm2004_regex.CMILangString250cr
|
|
},
|
|
'long-fill-in': {
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false,
|
|
duplicate: true,
|
|
format: scorm2004_regex.CMILangString4000
|
|
},
|
|
'matching': {
|
|
max: 36,
|
|
delimiter: '[,]',
|
|
delimiter2: '[.]',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: scorm2004_regex.CMIShortIdentifier,
|
|
format2: scorm2004_regex.CMIShortIdentifier
|
|
},
|
|
'performance': {
|
|
max: 250,
|
|
delimiter: '[,]',
|
|
delimiter2: '[.]',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: '^$|' + scorm2004_regex.CMIShortIdentifier,
|
|
format2: scorm2004_regex.CMIDecimal + '|^$|' + scorm2004_regex.CMIShortIdentifier
|
|
},
|
|
'sequencing': {
|
|
max: 36,
|
|
delimiter: '[,]',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: scorm2004_regex.CMIShortIdentifier
|
|
},
|
|
'likert': {
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: scorm2004_regex.CMIShortIdentifier,
|
|
limit: 1
|
|
},
|
|
'numeric': {
|
|
max: 2,
|
|
delimiter: '[:]',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: scorm2004_regex.CMIDecimal,
|
|
limit: 1
|
|
},
|
|
'other': {
|
|
max: 1,
|
|
delimiter: '',
|
|
unique: false,
|
|
duplicate: false,
|
|
format: scorm2004_regex.CMIString4000,
|
|
limit: 1
|
|
}
|
|
};
|
|
var Responses = {
|
|
learner: learner,
|
|
correct: correct
|
|
};
|
|
var _default = Responses;
|
|
exports["default"] = _default;
|
|
|
|
},{"./regex":9}],11:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.Scorm2004ValidationError = exports.AICCValidationError = exports.Scorm12ValidationError = exports.ValidationError = void 0;
|
|
|
|
var _api_constants = _interopRequireDefault(require("./constants/api_constants"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
|
|
|
|
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
|
|
|
|
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
|
|
|
|
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
|
|
|
|
function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
|
|
|
|
function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
|
|
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
|
|
|
|
function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
|
|
|
|
var scorm12_errors = _api_constants["default"].scorm12.error_descriptions;
|
|
var aicc_errors = _api_constants["default"].aicc.error_descriptions;
|
|
var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions;
|
|
/**
|
|
* Base Validation Exception
|
|
*/
|
|
|
|
var _errorCode = /*#__PURE__*/new WeakMap();
|
|
|
|
var _errorMessage = /*#__PURE__*/new WeakMap();
|
|
|
|
var _detailedMessage = /*#__PURE__*/new WeakMap();
|
|
|
|
var ValidationError = /*#__PURE__*/function (_Error) {
|
|
_inherits(ValidationError, _Error);
|
|
|
|
var _super = _createSuper(ValidationError);
|
|
|
|
/**
|
|
* Constructor to take in an error message and code
|
|
* @param {number} errorCode
|
|
* @param {string} errorMessage
|
|
* @param {string} detailedMessage
|
|
*/
|
|
function ValidationError(errorCode, errorMessage, detailedMessage) {
|
|
var _this;
|
|
|
|
_classCallCheck(this, ValidationError);
|
|
|
|
_this = _super.call(this, errorMessage);
|
|
|
|
_errorCode.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_errorMessage.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_detailedMessage.set(_assertThisInitialized(_this), {
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _errorMessage, errorMessage);
|
|
|
|
_classPrivateFieldSet(_assertThisInitialized(_this), _detailedMessage, detailedMessage);
|
|
|
|
return _this;
|
|
}
|
|
|
|
_createClass(ValidationError, [{
|
|
key: "errorCode",
|
|
get:
|
|
/**
|
|
* Getter for #errorCode
|
|
* @return {number}
|
|
*/
|
|
function get() {
|
|
return _classPrivateFieldGet(this, _errorCode);
|
|
}
|
|
/**
|
|
* Getter for #errorMessage
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "errorMessage",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _errorMessage);
|
|
}
|
|
/**
|
|
* Getter for #detailedMessage
|
|
* @return {string}
|
|
*/
|
|
|
|
}, {
|
|
key: "detailedMessage",
|
|
get: function get() {
|
|
return _classPrivateFieldGet(this, _detailedMessage);
|
|
}
|
|
}]);
|
|
|
|
return ValidationError;
|
|
}( /*#__PURE__*/_wrapNativeSuper(Error));
|
|
/**
|
|
* SCORM 1.2 Validation Error
|
|
*/
|
|
|
|
|
|
exports.ValidationError = ValidationError;
|
|
|
|
var Scorm12ValidationError = /*#__PURE__*/function (_ValidationError) {
|
|
_inherits(Scorm12ValidationError, _ValidationError);
|
|
|
|
var _super2 = _createSuper(Scorm12ValidationError);
|
|
|
|
/**
|
|
* Constructor to take in an error code
|
|
* @param {number} errorCode
|
|
*/
|
|
function Scorm12ValidationError(errorCode) {
|
|
var _this2;
|
|
|
|
_classCallCheck(this, Scorm12ValidationError);
|
|
|
|
if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {
|
|
_this2 = _super2.call(this, errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);
|
|
} else {
|
|
_this2 = _super2.call(this, 101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);
|
|
}
|
|
|
|
return _possibleConstructorReturn(_this2);
|
|
}
|
|
|
|
return Scorm12ValidationError;
|
|
}(ValidationError);
|
|
/**
|
|
* AICC Validation Error
|
|
*/
|
|
|
|
|
|
exports.Scorm12ValidationError = Scorm12ValidationError;
|
|
|
|
var AICCValidationError = /*#__PURE__*/function (_ValidationError2) {
|
|
_inherits(AICCValidationError, _ValidationError2);
|
|
|
|
var _super3 = _createSuper(AICCValidationError);
|
|
|
|
/**
|
|
* Constructor to take in an error code
|
|
* @param {number} errorCode
|
|
*/
|
|
function AICCValidationError(errorCode) {
|
|
var _this3;
|
|
|
|
_classCallCheck(this, AICCValidationError);
|
|
|
|
if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {
|
|
_this3 = _super3.call(this, errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);
|
|
} else {
|
|
_this3 = _super3.call(this, 101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);
|
|
}
|
|
|
|
return _possibleConstructorReturn(_this3);
|
|
}
|
|
|
|
return AICCValidationError;
|
|
}(ValidationError);
|
|
/**
|
|
* SCORM 2004 Validation Error
|
|
*/
|
|
|
|
|
|
exports.AICCValidationError = AICCValidationError;
|
|
|
|
var Scorm2004ValidationError = /*#__PURE__*/function (_ValidationError3) {
|
|
_inherits(Scorm2004ValidationError, _ValidationError3);
|
|
|
|
var _super4 = _createSuper(Scorm2004ValidationError);
|
|
|
|
/**
|
|
* Constructor to take in an error code
|
|
* @param {number} errorCode
|
|
*/
|
|
function Scorm2004ValidationError(errorCode) {
|
|
var _this4;
|
|
|
|
_classCallCheck(this, Scorm2004ValidationError);
|
|
|
|
if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {
|
|
_this4 = _super4.call(this, errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);
|
|
} else {
|
|
_this4 = _super4.call(this, 101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);
|
|
}
|
|
|
|
return _possibleConstructorReturn(_this4);
|
|
}
|
|
|
|
return Scorm2004ValidationError;
|
|
}(ValidationError);
|
|
|
|
exports.Scorm2004ValidationError = Scorm2004ValidationError;
|
|
|
|
},{"./constants/api_constants":6}],12:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
var _Scorm2004API = _interopRequireDefault(require("../Scorm2004API"));
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
|
|
|
|
window.Scorm2004API = _Scorm2004API["default"];
|
|
|
|
},{"../Scorm2004API":3}],13:[function(require,module,exports){
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.getSecondsAsHHMMSS = getSecondsAsHHMMSS;
|
|
exports.getSecondsAsISODuration = getSecondsAsISODuration;
|
|
exports.getTimeAsSeconds = getTimeAsSeconds;
|
|
exports.getDurationAsSeconds = getDurationAsSeconds;
|
|
exports.addTwoDurations = addTwoDurations;
|
|
exports.addHHMMSSTimeStrings = addHHMMSSTimeStrings;
|
|
exports.flatten = flatten;
|
|
exports.unflatten = unflatten;
|
|
exports.countDecimals = countDecimals;
|
|
exports.SECONDS_PER_DAY = exports.SECONDS_PER_HOUR = exports.SECONDS_PER_MINUTE = exports.SECONDS_PER_SECOND = void 0;
|
|
|
|
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
|
|
|
|
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
|
|
|
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
|
|
|
|
var SECONDS_PER_SECOND = 1.0;
|
|
exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND;
|
|
var SECONDS_PER_MINUTE = 60;
|
|
exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE;
|
|
var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;
|
|
exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR;
|
|
var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;
|
|
exports.SECONDS_PER_DAY = SECONDS_PER_DAY;
|
|
var designations = [['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
|
|
* @return {string}
|
|
*/
|
|
|
|
function getSecondsAsHHMMSS(totalSeconds) {
|
|
// SCORM spec does not deal with negative durations, give zero back
|
|
if (!totalSeconds || totalSeconds <= 0) {
|
|
return '00:00:00';
|
|
}
|
|
|
|
var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);
|
|
var dateObj = new Date(totalSeconds * 1000);
|
|
var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value
|
|
|
|
var seconds = dateObj.getSeconds();
|
|
var ms = totalSeconds % 1.0;
|
|
var msStr = '';
|
|
|
|
if (countDecimals(ms) > 0) {
|
|
if (countDecimals(ms) > 2) {
|
|
msStr = ms.toFixed(2);
|
|
} else {
|
|
msStr = String(ms);
|
|
}
|
|
|
|
msStr = '.' + msStr.split('.')[1];
|
|
}
|
|
|
|
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}
|
|
*/
|
|
|
|
|
|
function getSecondsAsISODuration(seconds) {
|
|
// SCORM spec does not deal with negative durations, give zero back
|
|
if (!seconds || seconds <= 0) {
|
|
return 'PT0S';
|
|
}
|
|
|
|
var duration = 'P';
|
|
var remainder = seconds;
|
|
designations.forEach(function (_ref) {
|
|
var _ref2 = _slicedToArray(_ref, 2),
|
|
sign = _ref2[0],
|
|
current_seconds = _ref2[1];
|
|
|
|
var 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) {
|
|
value += remainder;
|
|
}
|
|
|
|
if (value) {
|
|
if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) {
|
|
duration += 'T';
|
|
}
|
|
|
|
duration += "".concat(value).concat(sign);
|
|
}
|
|
});
|
|
return duration;
|
|
}
|
|
/**
|
|
* Calculate the number of seconds from HH:MM:SS.DDDDDD
|
|
*
|
|
* @param {string} timeString
|
|
* @param {RegExp} timeRegex
|
|
* @return {number}
|
|
*/
|
|
|
|
|
|
function getTimeAsSeconds(timeString, timeRegex) {
|
|
if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) {
|
|
return 0;
|
|
}
|
|
|
|
var parts = timeString.split(':');
|
|
var hours = Number(parts[0]);
|
|
var minutes = Number(parts[1]);
|
|
var seconds = Number(parts[2]);
|
|
return hours * 3600 + minutes * 60 + seconds;
|
|
}
|
|
/**
|
|
* Calculate the number of seconds from ISO 8601 Duration
|
|
*
|
|
* @param {string} duration
|
|
* @param {RegExp} durationRegex
|
|
* @return {number}
|
|
*/
|
|
|
|
|
|
function getDurationAsSeconds(duration, durationRegex) {
|
|
if (!duration || !duration.match(durationRegex)) {
|
|
return 0;
|
|
}
|
|
|
|
var _ref3 = new RegExp(durationRegex).exec(duration) || [],
|
|
_ref4 = _slicedToArray(_ref3, 8),
|
|
years = _ref4[1],
|
|
months = _ref4[2],
|
|
days = _ref4[4],
|
|
hours = _ref4[5],
|
|
minutes = _ref4[6],
|
|
seconds = _ref4[7];
|
|
|
|
var 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;
|
|
return result;
|
|
}
|
|
/**
|
|
* Adds together two ISO8601 Duration strings
|
|
*
|
|
* @param {string} first
|
|
* @param {string} second
|
|
* @param {RegExp} durationRegex
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
function addTwoDurations(first, second, durationRegex) {
|
|
return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex));
|
|
}
|
|
/**
|
|
* Add together two HH:MM:SS.DD strings
|
|
*
|
|
* @param {string} first
|
|
* @param {string} second
|
|
* @param {RegExp} timeRegex
|
|
* @return {string}
|
|
*/
|
|
|
|
|
|
function addHHMMSSTimeStrings(first, second, timeRegex) {
|
|
return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex));
|
|
}
|
|
/**
|
|
* Flatten a JSON object down to string paths for each values
|
|
* @param {object} data
|
|
* @return {object}
|
|
*/
|
|
|
|
|
|
function flatten(data) {
|
|
var result = {};
|
|
/**
|
|
* Recurse through the object
|
|
* @param {*} cur
|
|
* @param {*} prop
|
|
*/
|
|
|
|
function recurse(cur, prop) {
|
|
if (Object(cur) !== cur) {
|
|
result[prop] = cur;
|
|
} else if (Array.isArray(cur)) {
|
|
for (var i = 0, l = cur.length; i < l; i++) {
|
|
recurse(cur[i], prop + '[' + i + ']');
|
|
if (l === 0) result[prop] = [];
|
|
}
|
|
} else {
|
|
var isEmpty = true;
|
|
|
|
for (var p in cur) {
|
|
if ({}.hasOwnProperty.call(cur, p)) {
|
|
isEmpty = false;
|
|
recurse(cur[p], prop ? prop + '.' + p : p);
|
|
}
|
|
}
|
|
|
|
if (isEmpty && prop) result[prop] = {};
|
|
}
|
|
}
|
|
|
|
recurse(data, '');
|
|
return result;
|
|
}
|
|
/**
|
|
* Un-flatten a flat JSON object
|
|
* @param {object} data
|
|
* @return {object}
|
|
*/
|
|
|
|
|
|
function unflatten(data) {
|
|
'use strict';
|
|
|
|
if (Object(data) !== data || Array.isArray(data)) return data;
|
|
var regex = /\.?([^.[\]]+)|\[(\d+)]/g;
|
|
var result = {};
|
|
|
|
for (var p in data) {
|
|
if ({}.hasOwnProperty.call(data, p)) {
|
|
var cur = result;
|
|
var prop = '';
|
|
var m = regex.exec(p);
|
|
|
|
while (m) {
|
|
cur = cur[prop] || (cur[prop] = m[2] ? [] : {});
|
|
prop = m[2] || m[1];
|
|
m = regex.exec(p);
|
|
}
|
|
|
|
cur[prop] = data[p];
|
|
}
|
|
}
|
|
|
|
return result[''] || result;
|
|
}
|
|
/**
|
|
* Counts the number of decimal places
|
|
* @param {number} num
|
|
* @return {number}
|
|
*/
|
|
|
|
|
|
function countDecimals(num) {
|
|
if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;
|
|
var parts = num.toString().split('.')[1];
|
|
return parts.length || 0;
|
|
}
|
|
|
|
},{}]},{},[12])
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.debounce/index.js","src/BaseAPI.js","src/Scorm2004API.js","src/cmi/common.js","src/cmi/scorm2004_cmi.js","src/constants/api_constants.js","src/constants/error_codes.js","src/constants/language_constants.js","src/constants/regex.js","src/constants/response_constants.js","src/exceptions.js","src/exports/scorm2004.js","src/utilities.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACxXA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,mBAAmB,GAAG,yBAAW,OAAvC;AAEA;AACA;AACA;AACA;;;;;;;;IACqB,O;AAuCnB;AACF;AACA;AACA;AACA;AACA;AACE,mBAAY,WAAZ,EAAyB,QAAzB,EAAmC;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aA1CvB;AACV,QAAA,UAAU,EAAE,KADF;AAEV,QAAA,iBAAiB,EAAE,EAFT;AAGV,QAAA,WAAW,EAAE,KAHH;AAIV,QAAA,gBAAgB,EAAE,KAJR;AAKV,QAAA,YAAY,EAAE,KALJ;AAMV,QAAA,gBAAgB,EAAE,MANR;AAMgB;AAC1B,QAAA,qBAAqB,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","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","// @flow\nimport {CMIArray} from './cmi/common';\nimport {ValidationError} from './exceptions';\nimport ErrorCodes from './constants/error_codes';\nimport APIConstants from './constants/api_constants';\nimport {unflatten} from './utilities';\nimport debounce from 'lodash.debounce';\n\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered\n * abstract, and never initialized on it's own.\n */\nexport default class BaseAPI {\n  #timeout;\n  #error_codes;\n  #settings = {\n    autocommit: false,\n    autocommitSeconds: 10,\n    asyncCommit: false,\n    sendBeaconCommit: false,\n    lmsCommitUrl: false,\n    dataCommitFormat: 'json', // valid formats are 'json' or 'flattened', 'params'\n    commitRequestDataType: 'application/json;charset=UTF-8',\n    autoProgress: false,\n    logLevel: global_constants.LOG_LEVEL_ERROR,\n    selfReportSessionTime: false,\n    alwaysSendTotalTime: false,\n    strict_errors: true,\n    xhrHeaders: {},\n    xhrWithCredentials: false,\n    responseHandler: function(xhr) {\n      let result;\n      if (typeof xhr !== 'undefined') {\n        result = JSON.parse(xhr.responseText);\n        if (result === null || !{}.hasOwnProperty.call(result, 'result')) {\n          result = {};\n          if (xhr.status === 200) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        }\n      }\n      return result;\n    },\n  };\n  cmi;\n  startingData: {};\n\n  /**\n   * Constructor for Base API class. Sets some shared API fields, as well as\n   * sets up options for the API.\n   * @param {object} error_codes\n   * @param {object} settings\n   */\n  constructor(error_codes, settings) {\n    if (new.target === BaseAPI) {\n      throw new TypeError('Cannot construct BaseAPI instances directly');\n    }\n    this.currentState = global_constants.STATE_NOT_INITIALIZED;\n    this.lastErrorCode = 0;\n    this.listenerArray = [];\n\n    this.#timeout = null;\n    this.#error_codes = error_codes;\n\n    this.settings = settings;\n    this.apiLogLevel = this.settings.logLevel;\n    this.selfReportSessionTime = this.settings.selfReportSessionTime;\n  }\n\n  /**\n   * Initialize the API\n   * @param {string} callbackName\n   * @param {string} initializeMessage\n   * @param {string} terminationMessage\n   * @return {string}\n   */\n  initialize(\n      callbackName: String,\n      initializeMessage?: String,\n      terminationMessage?: String) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.isInitialized()) {\n      this.throwSCORMError(this.#error_codes.INITIALIZED, initializeMessage);\n    } else if (this.isTerminated()) {\n      this.throwSCORMError(this.#error_codes.TERMINATED, terminationMessage);\n    } else {\n      if (this.selfReportSessionTime) {\n        this.cmi.setStartTime();\n      }\n\n      this.currentState = global_constants.STATE_INITIALIZED;\n      this.lastErrorCode = 0;\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Getter for #error_codes\n   * @return {object}\n   */\n  get error_codes() {\n    return this.#error_codes;\n  }\n\n  /**\n   * Getter for #settings\n   * @return {object}\n   */\n  get settings() {\n    return this.#settings;\n  }\n\n  /**\n   * Setter for #settings\n   * @param {object} settings\n   */\n  set settings(settings: Object) {\n    this.#settings = {...this.#settings, ...settings};\n  }\n\n  /**\n   * Terminates the current run of the API\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  terminate(\n      callbackName: String,\n      checkTerminated: boolean) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.TERMINATION_BEFORE_INIT,\n        this.#error_codes.MULTIPLE_TERMINATION)) {\n      this.currentState = global_constants.STATE_TERMINATED;\n\n      const result = this.storeData(true);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          typeof result.errorCode !== 'undefined' && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Get the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  getValue(\n      callbackName: String,\n      checkTerminated: boolean,\n      CMIElement: String) {\n    let returnValue;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.RETRIEVE_BEFORE_INIT,\n        this.#error_codes.RETRIEVE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.getCMIValue(CMIElement);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement);\n    }\n\n    this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Sets the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {string} commitCallback\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setValue(\n      callbackName: String,\n      commitCallback: String,\n      checkTerminated: boolean,\n      CMIElement,\n      value) {\n    if (value !== undefined) {\n      value = String(value);\n    }\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.STORE_BEFORE_INIT,\n        this.#error_codes.STORE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.setCMIValue(CMIElement, value);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement, value);\n    }\n\n    if (returnValue === undefined) {\n      returnValue = global_constants.SCORM_FALSE;\n    }\n\n    // If we didn't have any errors while setting the data, go ahead and\n    // schedule a commit, if autocommit is turned on\n    if (String(this.lastErrorCode) === '0') {\n      if (this.settings.autocommit && !this.#timeout) {\n        this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);\n      }\n    }\n\n    this.apiLog(callbackName, CMIElement,\n        ': ' + value + ': result: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  commit(\n      callbackName: String,\n      checkTerminated: boolean) {\n    this.clearScheduledCommit();\n\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n        this.#error_codes.COMMIT_AFTER_TERM)) {\n      const result = this.storeData(false);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          result.errorCode && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue,\n          global_constants.LOG_LEVEL_DEBUG);\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns last error code\n   * @param {string} callbackName\n   * @return {string}\n   */\n  getLastError(callbackName: String) {\n    const returnValue = String(this.lastErrorCode);\n\n    this.processListeners(callbackName);\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getErrorString(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getDiagnostic(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Checks the LMS state and ensures it has been initialized.\n   *\n   * @param {boolean} checkTerminated\n   * @param {number} beforeInitError\n   * @param {number} afterTermError\n   * @return {boolean}\n   */\n  checkState(\n      checkTerminated: boolean,\n      beforeInitError: number,\n      afterTermError?: number) {\n    if (this.isNotInitialized()) {\n      this.throwSCORMError(beforeInitError);\n      return false;\n    } else if (checkTerminated && this.isTerminated()) {\n      this.throwSCORMError(afterTermError);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Logging for all SCORM actions\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} logMessage\n   * @param {number}messageLevel\n   */\n  apiLog(\n      functionName: String,\n      CMIElement: String,\n      logMessage: String,\n      messageLevel: number) {\n    logMessage = this.formatMessage(functionName, CMIElement, logMessage);\n\n    if (messageLevel >= this.apiLogLevel) {\n      switch (messageLevel) {\n        case global_constants.LOG_LEVEL_ERROR:\n          console.error(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_WARNING:\n          console.warn(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_INFO:\n          console.info(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_DEBUG:\n          if (console.debug) {\n            console.debug(logMessage);\n          } else {\n            console.log(logMessage);\n          }\n          break;\n      }\n    }\n  }\n\n  /**\n   * Formats the SCORM messages for easy reading\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} message\n   * @return {string}\n   */\n  formatMessage(functionName: String, CMIElement: String, message: String) {\n    const baseLength = 20;\n    let messageString = '';\n\n    messageString += functionName;\n\n    let fillChars = baseLength - messageString.length;\n\n    for (let i = 0; i < fillChars; i++) {\n      messageString += ' ';\n    }\n\n    messageString += ': ';\n\n    if (CMIElement) {\n      const CMIElementBaseLength = 70;\n\n      messageString += CMIElement;\n\n      fillChars = CMIElementBaseLength - messageString.length;\n\n      for (let j = 0; j < fillChars; j++) {\n        messageString += ' ';\n      }\n    }\n\n    if (message) {\n      messageString += message;\n    }\n\n    return messageString;\n  }\n\n  /**\n   * Checks to see if {str} contains {tester}\n   *\n   * @param {string} str String to check against\n   * @param {string} tester String to check for\n   * @return {boolean}\n   */\n  stringMatches(str: String, tester: String) {\n    return str && tester && str.match(tester);\n  }\n\n  /**\n   * Check to see if the specific object has the given property\n   * @param {*} refObject\n   * @param {string} attribute\n   * @return {boolean}\n   * @private\n   */\n  _checkObjectHasProperty(refObject, attribute: String) {\n    return Object.hasOwnProperty.call(refObject, attribute) ||\n        Object.getOwnPropertyDescriptor(\n            Object.getPrototypeOf(refObject), attribute) ||\n        (attribute in refObject);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {(string|number)} _errorNumber\n   * @param {boolean} _detail\n   * @return {string}\n   * @abstract\n   */\n  getLmsErrorMessageDetails(_errorNumber, _detail) {\n    throw new Error(\n        'The getLmsErrorMessageDetails method has not been implemented');\n  }\n\n  /**\n   * Gets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @return {string}\n   * @abstract\n   */\n  getCMIValue(_CMIElement) {\n    throw new Error('The getCMIValue method has not been implemented');\n  }\n\n  /**\n   * Sets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @param {any} _value\n   * @return {string}\n   * @abstract\n   */\n  setCMIValue(_CMIElement, _value) {\n    throw new Error('The setCMIValue method has not been implemented');\n  }\n\n  /**\n   * Shared API method to set a valid for a given element.\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  _commonSetCMIValue(\n      methodName: String, scorm2004: boolean, CMIElement, value) {\n    if (!CMIElement || CMIElement === '') {\n      return global_constants.SCORM_FALSE;\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let returnValue = global_constants.SCORM_FALSE;\n    let foundFirstIndex = false;\n\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      const attribute = structure[i];\n\n      if (i === structure.length - 1) {\n        if (scorm2004 && (attribute.substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          this.throwSCORMError(this.#error_codes.READ_ONLY_ELEMENT);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        } else {\n          if (this.isInitialized() &&\n              this.stringMatches(CMIElement, '\\\\.correct_responses\\\\.\\\\d+')) {\n            this.validateCorrectResponse(CMIElement, value);\n          }\n\n          if (!scorm2004 || this.lastErrorCode === 0) {\n            refObject[attribute] = value;\n            returnValue = global_constants.SCORM_TRUE;\n          }\n        }\n      } else {\n        refObject = refObject[attribute];\n        if (!refObject) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          break;\n        }\n\n        if (refObject instanceof CMIArray) {\n          const index = parseInt(structure[i + 1], 10);\n\n          // SCO is trying to set an item on an array\n          if (!isNaN(index)) {\n            const item = refObject.childArray[index];\n\n            if (item) {\n              refObject = item;\n              foundFirstIndex = true;\n            } else {\n              const newChild = this.getChildElement(CMIElement, value,\n                  foundFirstIndex);\n              foundFirstIndex = true;\n\n              if (!newChild) {\n                this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n              } else {\n                if (refObject.initialized) newChild.initialize();\n\n                refObject.childArray.push(newChild);\n                refObject = newChild;\n              }\n            }\n\n            // Have to update i value to skip the array position\n            i++;\n          }\n        }\n      }\n    }\n\n    if (returnValue === global_constants.SCORM_FALSE) {\n      this.apiLog(methodName, null,\n          `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n          global_constants.LOG_LEVEL_WARNING);\n    }\n\n    return returnValue;\n  }\n\n  /**\n   * Abstract method for validating that a response is correct.\n   *\n   * @param {string} _CMIElement\n   * @param {*} _value\n   */\n  validateCorrectResponse(_CMIElement, _value) {\n    // just a stub method\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   * APIs that inherit BaseAPI should override this method.\n   *\n   * @param {string} _CMIElement - unused\n   * @param {*} _value - unused\n   * @param {boolean} _foundFirstIndex - unused\n   * @return {*}\n   * @abstract\n   */\n  getChildElement(_CMIElement, _value, _foundFirstIndex) {\n    throw new Error('The getChildElement method has not been implemented');\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  _commonGetCMIValue(methodName: String, scorm2004: boolean, CMIElement) {\n    if (!CMIElement || CMIElement === '') {\n      return '';\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let attribute = null;\n\n    const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      attribute = structure[i];\n\n      if (!scorm2004) {\n        if (i === structure.length - 1) {\n          if (!this._checkObjectHasProperty(refObject, attribute)) {\n            this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n            return;\n          }\n        }\n      } else {\n        if ((String(attribute).substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          const target = String(attribute).\n              substr(8, String(attribute).length - 9);\n          return refObject._isTargetValid(target);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          return;\n        }\n      }\n\n      refObject = refObject[attribute];\n      if (refObject === undefined) {\n        this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        break;\n      }\n\n      if (refObject instanceof CMIArray) {\n        const index = parseInt(structure[i + 1], 10);\n\n        // SCO is trying to set an item on an array\n        if (!isNaN(index)) {\n          const item = refObject.childArray[index];\n\n          if (item) {\n            refObject = item;\n          } else {\n            this.throwSCORMError(this.#error_codes.VALUE_NOT_INITIALIZED,\n                uninitializedErrorMessage);\n            break;\n          }\n\n          // Have to update i value to skip the array position\n          i++;\n        }\n      }\n    }\n\n    if (refObject === null || refObject === undefined) {\n      if (!scorm2004) {\n        if (attribute === '_children') {\n          this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);\n        } else if (attribute === '_count') {\n          this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);\n        }\n      }\n    } else {\n      return refObject;\n    }\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isInitialized() {\n    return this.currentState === global_constants.STATE_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_NOT_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isNotInitialized() {\n    return this.currentState === global_constants.STATE_NOT_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_TERMINATED\n   *\n   * @return {boolean}\n   */\n  isTerminated() {\n    return this.currentState === global_constants.STATE_TERMINATED;\n  }\n\n  /**\n   * Provides a mechanism for attaching to a specific SCORM event\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  on(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray.push({\n        functionName: functionName,\n        CMIElement: CMIElement,\n        callback: callback,\n      });\n\n      this.apiLog('on', functionName, `Added event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n    }\n  }\n\n  /**\n   * Provides a mechanism for detaching a specific SCORM event listener\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  off(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      const removeIndex = this.listenerArray.findIndex((obj) =>\n        obj.functionName === functionName &&\n        obj.CMIElement === CMIElement &&\n        obj.callback === callback\n      );\n      if (removeIndex !== -1) {\n        this.listenerArray.splice(removeIndex, 1);\n        this.apiLog('off', functionName, `Removed event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n      }\n    }\n  }\n\n  /**\n   * Provides a mechanism for clearing all listeners from a specific SCORM event\n   *\n   * @param {string} listenerName\n   */\n  clear(listenerName: String) {\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray = this.listenerArray.filter((obj) =>\n        obj.functionName !== functionName &&\n        obj.CMIElement !== CMIElement,\n      );\n    }\n  }\n\n  /**\n   * Processes any 'on' listeners that have been created\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  processListeners(functionName: String, CMIElement: String, value: any) {\n    this.apiLog(functionName, CMIElement, value);\n    for (let i = 0; i < this.listenerArray.length; i++) {\n      const listener = this.listenerArray[i];\n      const functionsMatch = listener.functionName === functionName;\n      const listenerHasCMIElement = !!listener.CMIElement;\n      let CMIElementsMatch = false;\n      if (CMIElement && listener.CMIElement &&\n          listener.CMIElement.substring(listener.CMIElement.length - 1) ===\n          '*') {\n        CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0,\n            listener.CMIElement.length - 1)) === 0;\n      } else {\n        CMIElementsMatch = listener.CMIElement === CMIElement;\n      }\n\n      if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {\n        listener.callback(CMIElement, value);\n      }\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} errorNumber\n   * @param {string} message\n   */\n  throwSCORMError(errorNumber: number, message: String) {\n    if (!message) {\n      message = this.getLmsErrorMessageDetails(errorNumber);\n    }\n\n    this.apiLog('throwSCORMError', null, errorNumber + ': ' + message,\n        global_constants.LOG_LEVEL_ERROR);\n\n    this.lastErrorCode = String(errorNumber);\n  }\n\n  /**\n   * Clears the last SCORM error code on success.\n   *\n   * @param {string} success\n   */\n  clearSCORMError(success: String) {\n    if (success !== undefined && success !== global_constants.SCORM_FALSE) {\n      this.lastErrorCode = 0;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS, logs data if no LMS configured\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _calculateTotalTime\n   * @return {string}\n   * @abstract\n   */\n  storeData(_calculateTotalTime) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Load the CMI from a flattened JSON object\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromFlattenedJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromFlattenedJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    /**\n     * Test match pattern.\n     *\n     * @param {string} a\n     * @param {string} c\n     * @param {RegExp} a_pattern\n     * @return {number}\n     */\n    function testPattern(a, c, a_pattern) {\n      const a_match = a.match(a_pattern);\n\n      let c_match;\n      if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {\n        const a_num = Number(a_match[2]);\n        const c_num = Number(c_match[2]);\n        if (a_num === c_num) {\n          if (a_match[3] === 'id') {\n            return -1;\n          } else if (a_match[3] === 'type') {\n            if (c_match[3] === 'id') {\n              return 1;\n            } else {\n              return -1;\n            }\n          } else {\n            return 1;\n          }\n        }\n        return a_num - c_num;\n      }\n\n      return null;\n    }\n\n    const int_pattern = /^(cmi\\.interactions\\.)(\\d+)\\.(.*)$/;\n    const obj_pattern = /^(cmi\\.objectives\\.)(\\d+)\\.(.*)$/;\n\n    const result = Object.keys(json).map(function(key) {\n      return [String(key), json[key]];\n    });\n\n    // CMI interactions need to have id and type loaded before any other fields\n    result.sort(function([a, b], [c, d]) {\n      let test;\n      if ((test = testPattern(a, c, int_pattern)) !== null) {\n        return test;\n      }\n      if ((test = testPattern(a, c, obj_pattern)) !== null) {\n        return test;\n      }\n\n      if (a < c) {\n        return -1;\n      }\n      if (a > c) {\n        return 1;\n      }\n      return 0;\n    });\n\n    let obj;\n    result.forEach((element) => {\n      obj = {};\n      obj[element[0]] = element[1];\n      this.loadFromJSON(unflatten(obj), CMIElement);\n    });\n  }\n\n  /**\n   * Loads CMI data from a JSON object.\n   *\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';\n\n    this.startingData = json;\n\n    // could this be refactored down to flatten(json) then setCMIValue on each?\n    for (const key in json) {\n      if ({}.hasOwnProperty.call(json, key) && json[key]) {\n        const currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;\n        const value = json[key];\n\n        if (value['childArray']) {\n          for (let i = 0; i < value['childArray'].length; i++) {\n            this.loadFromJSON(value['childArray'][i],\n                currentCMIElement + '.' + i);\n          }\n        } else if (value.constructor === Object) {\n          this.loadFromJSON(value, currentCMIElement);\n        } else {\n          this.setCMIValue(currentCMIElement, value);\n        }\n      }\n    }\n  }\n\n  /**\n   * Render the CMI object to JSON for sending to an LMS.\n   *\n   * @return {string}\n   */\n  renderCMIToJSONString() {\n    const cmi = this.cmi;\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.stringify({cmi});\n  }\n\n  /**\n   * Returns a JS object representing the current cmi\n   * @return {object}\n   */\n  renderCMIToJSONObject() {\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.parse(this.renderCMIToJSONString());\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _terminateCommit\n   * @return {*}\n   * @abstract\n   */\n  renderCommitCMI(_terminateCommit) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Send the request to the LMS\n   * @param {string} url\n   * @param {object|Array} params\n   * @param {boolean} immediate\n   * @return {object}\n   */\n  processHttpRequest(url: String, params, immediate = false) {\n    const api = this;\n    const process = function(url, params, settings, error_codes) {\n      const genericError = {\n        'result': global_constants.SCORM_FALSE,\n        'errorCode': error_codes.GENERAL,\n      };\n\n      let result;\n      if (!settings.sendBeaconCommit) {\n        const httpReq = new XMLHttpRequest();\n        httpReq.open('POST', url, settings.asyncCommit);\n\n        if(Object.keys(settings.xhrHeaders).length) {\n          Object.keys(settings.xhrHeaders).forEach((header) => {\n            httpReq.setRequestHeader(header, settings.xhrHeaders[header])\n          })\n        }\n\n        httpReq.withCredentials = settings.xhrWithCredentials\n\n        if (settings.asyncCommit) {\n          httpReq.onload = function(e) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          };\n        }\n        try {\n          if (params instanceof Array) {\n            httpReq.setRequestHeader('Content-Type',\n                'application/x-www-form-urlencoded');\n            httpReq.send(params.join('&'));\n          } else {\n            httpReq.setRequestHeader('Content-Type',\n                settings.commitRequestDataType);\n            httpReq.send(JSON.stringify(params));\n          }\n\n          if (!settings.asyncCommit) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          } else {\n            result = {};\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n            api.processListeners('CommitSuccess');\n            return result;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      } else {\n        try {\n          const headers = {\n            type: settings.commitRequestDataType,\n          };\n          let blob;\n          if (params instanceof Array) {\n            blob = new Blob([params.join('&')], headers);\n          } else {\n            blob = new Blob([JSON.stringify(params)], headers);\n          }\n\n          result = {};\n          if (navigator.sendBeacon(url, blob)) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      }\n\n      if (typeof result === 'undefined') {\n        api.processListeners('CommitError');\n        return genericError;\n      }\n\n      if (result.result === true ||\n          result.result === global_constants.SCORM_TRUE) {\n        api.processListeners('CommitSuccess');\n      } else {\n        api.processListeners('CommitError');\n      }\n\n      return result;\n    };\n\n    if (typeof debounce !== 'undefined') {\n      const debounced = debounce(process, 500);\n      debounced(url, params, this.settings, this.error_codes);\n\n      // if we're terminating, go ahead and commit immediately\n      if (immediate) {\n        debounced.flush();\n      }\n\n      return {\n        result: global_constants.SCORM_TRUE,\n        errorCode: 0,\n      };\n    } else {\n      return process(url, params, this.settings, this.error_codes);\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} when - the number of milliseconds to wait before committing\n   * @param {string} callback - the name of the commit event callback\n   */\n  scheduleCommit(when: number, callback: string) {\n    this.#timeout = new ScheduledCommit(this, when, callback);\n    this.apiLog('scheduleCommit', '', 'scheduled',\n        global_constants.LOG_LEVEL_DEBUG);\n  }\n\n  /**\n   * Clears and cancels any currently scheduled commits\n   */\n  clearScheduledCommit() {\n    if (this.#timeout) {\n      this.#timeout.cancel();\n      this.#timeout = null;\n      this.apiLog('clearScheduledCommit', '', 'cleared',\n          global_constants.LOG_LEVEL_DEBUG);\n    }\n  }\n}\n\n/**\n * Private class that wraps a timeout call to the commit() function\n */\nclass ScheduledCommit {\n  #API;\n  #cancelled = false;\n  #timeout;\n  #callback;\n\n  /**\n   * Constructor for ScheduledCommit\n   * @param {BaseAPI} API\n   * @param {number} when\n   * @param {string} callback\n   */\n  constructor(API: any, when: number, callback: string) {\n    this.#API = API;\n    this.#timeout = setTimeout(this.wrapper.bind(this), when);\n    this.#callback = callback;\n  }\n\n  /**\n   * Cancel any currently scheduled commit\n   */\n  cancel() {\n    this.#cancelled = true;\n    if (this.#timeout) {\n      clearTimeout(this.#timeout);\n    }\n  }\n\n  /**\n   * Wrap the API commit call to check if the call has already been cancelled\n   */\n  wrapper() {\n    if (!this.#cancelled) {\n      this.#API.commit(this.#callback);\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  ADL,\n  CMI,\n  CMICommentsObject,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject,\n} from './cmi/scorm2004_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\nimport Responses from './constants/response_constants';\nimport ValidLanguages from './constants/language_constants';\nimport Regex from './constants/regex';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst global_constants = APIConstants.global;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst correct_responses = Responses.correct;\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * API class for SCORM 2004\n */\nexport default class Scorm2004API extends BaseAPI {\n  #version: '1.0';\n\n  /**\n   * Constructor for SCORM 2004 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm2004_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.adl = new ADL();\n\n    // Rename functions to match 2004 Spec and expose to modules\n    this.Initialize = this.lmsInitialize;\n    this.Terminate = this.lmsTerminate;\n    this.GetValue = this.lmsGetValue;\n    this.SetValue = this.lmsSetValue;\n    this.Commit = this.lmsCommit;\n    this.GetLastError = this.lmsGetLastError;\n    this.GetErrorString = this.lmsGetErrorString;\n    this.GetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * Getter for #version\n   * @return {string}\n   */\n  get version() {\n    return this.#version;\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('Initialize');\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsTerminate() {\n    const result = this.terminate('Terminate', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.adl.nav.request !== '_none_') {\n        switch (this.adl.nav.request) {\n          case 'continue':\n            this.processListeners('SequenceNext');\n            break;\n          case 'previous':\n            this.processListeners('SequencePrevious');\n            break;\n          case 'choice':\n            this.processListeners('SequenceChoice');\n            break;\n          case 'exit':\n            this.processListeners('SequenceExit');\n            break;\n          case 'exitAll':\n            this.processListeners('SequenceExitAll');\n            break;\n          case 'abandon':\n            this.processListeners('SequenceAbandon');\n            break;\n          case 'abandonAll':\n            this.processListeners('SequenceAbandonAll');\n            break;\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('SetValue', 'Commit', true, CMIElement, value);\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('Commit');\n  }\n\n  /**\n   * Returns last error code\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('GetLastError');\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('GetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('GetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('SetValue', true, CMIElement, value);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @param {boolean} foundFirstIndex\n   * @return {any}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      const parts = CMIElement.split('.');\n      const index = Number(parts[2]);\n      const interaction = this.cmi.interactions.childArray[index];\n      if (this.isInitialized()) {\n        if (!interaction.type) {\n          this.throwSCORMError(\n              scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n        } else {\n          this.checkDuplicateChoiceResponse(interaction, value);\n\n          const response_type = correct_responses[interaction.type];\n          if (response_type) {\n            this.checkValidResponseType(response_type, value, interaction.type);\n          } else {\n            this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n                'Incorrect Response Type: ' + interaction.type);\n          }\n        }\n      }\n      if (this.lastErrorCode === 0) {\n        newChild = new CMIInteractionsCorrectResponsesObject();\n      }\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_learner\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_lms\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject(true);\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Checks for valid response types\n   * @param {object} response_type\n   * @param {any} value\n   * @param {string} interaction_type\n   */\n  checkValidResponseType(response_type, value, interaction_type) {\n    let nodes = [];\n    if (response_type?.delimiter) {\n      nodes = String(value).split(response_type.delimiter);\n    } else {\n      nodes[0] = value;\n    }\n\n    if (nodes.length > 0 && nodes.length <= response_type.max) {\n      this.checkCorrectResponseValue(interaction_type, nodes, value);\n    } else if (nodes.length > response_type.max) {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Pattern Too Long');\n    }\n  }\n\n  /**\n   * Checks for duplicate 'choice' responses.\n   * @param {CMIInteractionsObject} interaction\n   * @param {any} value\n   */\n  checkDuplicateChoiceResponse(interaction, value) {\n    const interaction_count = interaction.correct_responses._count;\n    if (interaction.type === 'choice') {\n      for (let i = 0; i < interaction_count && this.lastErrorCode ===\n      0; i++) {\n        const response = interaction.correct_responses.childArray[i];\n        if (response.pattern === value) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n        }\n      }\n    }\n  }\n\n  /**\n   * Validate correct response.\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  validateCorrectResponse(CMIElement, value) {\n    const parts = CMIElement.split('.');\n    const index = Number(parts[2]);\n    const pattern_index = Number(parts[4]);\n    const interaction = this.cmi.interactions.childArray[index];\n\n    const interaction_count = interaction.correct_responses._count;\n    this.checkDuplicateChoiceResponse(interaction, value);\n\n    const response_type = correct_responses[interaction.type];\n    if (typeof response_type.limit === 'undefined' || interaction_count <=\n        response_type.limit) {\n      this.checkValidResponseType(response_type, value, interaction.type);\n\n      if (this.lastErrorCode === 0 &&\n          (!response_type.duplicate ||\n              !this.checkDuplicatedPattern(interaction.correct_responses,\n                  pattern_index, value)) ||\n          (this.lastErrorCode === 0 && value === '')) {\n        // do nothing, we want the inverse\n      } else {\n        if (this.lastErrorCode === 0) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n              'Data Model Element Pattern Already Exists');\n        }\n      }\n    } else {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Collection Limit Reached');\n    }\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {(string|number)} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = '';\n    let detailMessage = '';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm2004_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Check to see if a correct_response value has been duplicated\n   * @param {CMIArray} correct_response\n   * @param {number} current_index\n   * @param {*} value\n   * @return {boolean}\n   */\n  checkDuplicatedPattern = (correct_response, current_index, value) => {\n    let found = false;\n    const count = correct_response._count;\n    for (let i = 0; i < count && !found; i++) {\n      if (i !== current_index && correct_response.childArray[i] === value) {\n        found = true;\n      }\n    }\n    return found;\n  };\n\n  /**\n   * Checks for a valid correct_response value\n   * @param {string} interaction_type\n   * @param {Array} nodes\n   * @param {*} value\n   */\n  checkCorrectResponseValue(interaction_type, nodes, value) {\n    const response = correct_responses[interaction_type];\n    const formatRegex = new RegExp(response.format);\n    for (let i = 0; i < nodes.length && this.lastErrorCode === 0; i++) {\n      if (interaction_type.match(\n          '^(fill-in|long-fill-in|matching|performance|sequencing)$')) {\n        nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]);\n      }\n\n      if (response?.delimiter2) {\n        const values = nodes[i].split(response.delimiter2);\n        if (values.length === 2) {\n          const matches = values[0].match(formatRegex);\n          if (!matches) {\n            this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n          } else {\n            if (!values[1].match(new RegExp(response.format2))) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n        } else {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        }\n      } else {\n        const matches = nodes[i].match(formatRegex);\n        if ((!matches && value !== '') ||\n            (!matches && interaction_type === 'true-false')) {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        } else {\n          if (interaction_type === 'numeric' && nodes.length > 1) {\n            if (Number(nodes[0]) > Number(nodes[1])) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          } else {\n            if (nodes[i] !== '' && response.unique) {\n              for (let j = 0; j < i && this.lastErrorCode === 0; j++) {\n                if (nodes[i] === nodes[j]) {\n                  this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Remove prefixes from correct_response\n   * @param {string} node\n   * @return {*}\n   */\n  removeCorrectResponsePrefixes(node) {\n    let seenOrder = false;\n    let seenCase = false;\n    let seenLang = false;\n\n    const prefixRegex = new RegExp(\n        '^({(lang|case_matters|order_matters)=([^}]+)})');\n    let matches = node.match(prefixRegex);\n    let langMatches = null;\n    while (matches) {\n      switch (matches[2]) {\n        case 'lang':\n          langMatches = node.match(scorm2004_regex.CMILangcr);\n          if (langMatches) {\n            const lang = langMatches[3];\n            if (lang !== undefined && lang.length > 0) {\n              if (ValidLanguages[lang.toLowerCase()] === undefined) {\n                this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n              }\n            }\n          }\n          seenLang = true;\n          break;\n        case 'case_matters':\n          if (!seenLang && !seenOrder && !seenCase) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenCase = true;\n          break;\n        case 'order_matters':\n          if (!seenCase && !seenLang && !seenOrder) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenOrder = true;\n          break;\n        default:\n          break;\n      }\n      node = node.substr(matches[1].length);\n      matches = node.match(prefixRegex);\n    }\n\n    return node;\n  }\n\n  /**\n   * Replace the whole API with another\n   * @param {Scorm2004API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n    this.adl = newAPI.adl;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      if (this.cmi.mode === 'normal') {\n        if (this.cmi.credit === 'credit') {\n          if (this.cmi.completion_threshold && this.cmi.progress_measure) {\n            if (this.cmi.progress_measure >= this.cmi.completion_threshold) {\n              console.debug('Setting Completion Status: Completed');\n              this.cmi.completion_status = 'completed';\n            } else {\n              console.debug('Setting Completion Status: Incomplete');\n              this.cmi.completion_status = 'incomplete';\n            }\n          }\n          if (this.cmi.scaled_passing_score && this.cmi.score.scaled) {\n            if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) {\n              console.debug('Setting Success Status: Passed');\n              this.cmi.success_status = 'passed';\n            } else {\n              console.debug('Setting Success Status: Failed');\n              this.cmi.success_status = 'failed';\n            }\n          }\n        }\n      }\n    }\n\n    let navRequest = false;\n    if (this.adl.nav.request !== (this.startingData?.adl?.nav?.request) &&\n        this.adl.nav.request !== '_none_') {\n      this.adl.nav.request = encodeURIComponent(this.adl.nav.request);\n      navRequest = true;\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' +\n            (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      const result = this.processHttpRequest(this.settings.lmsCommitUrl,\n          commitObject, terminateCommit);\n\n      // check if this is a sequencing call, and then call the necessary JS\n      {\n        if (navRequest && result.navRequest !== undefined &&\n            result.navRequest !== '') {\n          Function(`\"use strict\";(() => { ${result.navRequest} })()`)();\n        }\n      }\n      return result;\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","// @flow\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Check if the value matches the proper format. If not, throw proper error code.\n *\n * @param {string} value\n * @param {string} regexPattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n    value: String,\n    regexPattern: String,\n    errorCode: number,\n    errorClass: function,\n    allowEmptyString?: boolean) {\n  const formatRegex = new RegExp(regexPattern);\n  const matches = value.match(formatRegex);\n  if (allowEmptyString && value === '') {\n    return true;\n  }\n  if (value === undefined || !matches || matches[0] === '') {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n  return true;\n}\n\n/**\n * Check if the value matches the proper range. If not, throw proper error code.\n *\n * @param {*} value\n * @param {string} rangePattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @return {boolean}\n */\nexport function checkValidRange(\n    value: any,\n    rangePattern: String,\n    errorCode: number,\n    errorClass: function) {\n  const ranges = rangePattern.split('#');\n  value = value * 1.0;\n  if (value >= ranges[0]) {\n    if ((ranges[1] === '*') || (value <= ranges[1])) {\n      return true;\n    } else {\n      throw new errorClass.prototype.constructor(errorCode);\n    }\n  } else {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n  jsonString = false;\n  #initialized = false;\n  #start_time;\n\n  /**\n   * Constructor for BaseCMI, just marks the class as abstract\n   */\n  constructor() {\n    if (new.target === BaseCMI) {\n      throw new TypeError('Cannot construct BaseCMI instances directly');\n    }\n  }\n\n  /**\n   * Getter for #initialized\n   * @return {boolean}\n   */\n  get initialized() {\n    return this.#initialized;\n  }\n\n  /**\n   * Getter for #start_time\n   * @return {Number}\n   */\n  get start_time() {\n    return this.#start_time;\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    this.#initialized = true;\n  }\n\n  /**\n   * Called when the player should override the 'session_time' provided by\n   * the module\n   */\n  setStartTime() {\n    this.#start_time = new Date().getTime();\n  }\n}\n\n/**\n * Base class for cmi *.score objects\n */\nexport class CMIScore extends BaseCMI {\n  /**\n   * Constructor for *.score\n   * @param {string} score_children\n   * @param {string} score_range\n   * @param {string} max\n   * @param {number} invalidErrorCode\n   * @param {number} invalidTypeCode\n   * @param {number} invalidRangeCode\n   * @param {string} decimalRegex\n   * @param {class} errorClass\n   */\n  constructor(\n      {\n        score_children,\n        score_range,\n        max,\n        invalidErrorCode,\n        invalidTypeCode,\n        invalidRangeCode,\n        decimalRegex,\n        errorClass,\n      }) {\n    super();\n\n    this.#_children = score_children ||\n        scorm12_constants.score_children;\n    this.#_score_range = !score_range ? false : scorm12_regex.score_range;\n    this.#max = (max || max === '') ? max : '100';\n    this.#_invalid_error_code = invalidErrorCode ||\n        scorm12_error_codes.INVALID_SET_VALUE;\n    this.#_invalid_type_code = invalidTypeCode ||\n        scorm12_error_codes.TYPE_MISMATCH;\n    this.#_invalid_range_code = invalidRangeCode ||\n        scorm12_error_codes.VALUE_OUT_OF_RANGE;\n    this.#_decimal_regex = decimalRegex ||\n        scorm12_regex.CMIDecimal;\n    this.#_error_class = errorClass;\n  }\n\n  #_children;\n  #_score_range;\n  #_invalid_error_code;\n  #_invalid_type_code;\n  #_invalid_range_code;\n  #_decimal_regex;\n  #_error_class;\n  #raw = '';\n  #min = '';\n  #max;\n\n  /**\n   * Getter for _children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throw new this.#_error_class.prototype.constructor(this.#_invalid_error_code);\n  }\n\n  /**\n   * Getter for #raw\n   * @return {string}\n   */\n  get raw() {\n    return this.#raw;\n  }\n\n  /**\n   * Setter for #raw\n   * @param {string} raw\n   */\n  set raw(raw) {\n    if (checkValidFormat(raw, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(raw, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#raw = raw;\n    }\n  }\n\n  /**\n   * Getter for #min\n   * @return {string}\n   */\n  get min() {\n    return this.#min;\n  }\n\n  /**\n   * Setter for #min\n   * @param {string} min\n   */\n  set min(min) {\n    if (checkValidFormat(min, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(min, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#min = min;\n    }\n  }\n\n  /**\n   * Getter for #max\n   * @return {string}\n   */\n  get max() {\n    return this.#max;\n  }\n\n  /**\n   * Setter for #max\n   * @param {string} max\n   */\n  set max(max) {\n    if (checkValidFormat(max, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(max, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#max = max;\n    }\n  }\n\n  /**\n   * toJSON for *.score\n   * @return {{min: string, max: string, raw: string}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'raw': this.raw,\n      'min': this.min,\n      'max': this.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Base class for cmi *.n objects\n */\nexport class CMIArray extends BaseCMI {\n  /**\n   * Constructor cmi *.n arrays\n   * @param {string} children\n   * @param {number} errorCode\n   * @param {class} errorClass\n   */\n  constructor({children, errorCode, errorClass}) {\n    super();\n    this.#_children = children;\n    this.#errorCode = errorCode;\n    this.#errorClass = errorClass;\n    this.childArray = [];\n  }\n\n  #errorCode;\n  #errorClass;\n  #_children;\n\n  /**\n   * Getter for _children\n   * @return {*}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * Getter for _count\n   * @return {number}\n   */\n  get _count() {\n    return this.childArray.length;\n  }\n\n  /**\n   * Setter for _count. Just throws an error.\n   * @param {number} _count\n   */\n  set _count(_count) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * toJSON for *.n arrays\n   * @return {object}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {};\n    for (let i = 0; i < this.childArray.length; i++) {\n      result[i + ''] = this.childArray[i];\n    }\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport Responses from '../constants/response_constants';\nimport {Scorm2004ValidationError} from '../exceptions';\nimport * as Util from '../utilities';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst learner_responses = Responses.learner;\n\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nfunction throwWriteOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Type Mismatch error\n */\nfunction throwTypeMismatchError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwDependencyNotEstablishedError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwGeneralSetError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction check2004ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm2004_error_codes.TYPE_MISMATCH,\n      Scorm2004ValidationError,\n      allowEmptyString,\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @return {boolean}\n */\nfunction check2004ValidRange(value: any, rangePattern: String) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm2004ValidationError,\n  );\n}\n\n/**\n * Class representing cmi object for SCORM 2004\n */\nexport class CMI extends BaseCMI {\n  /**\n   * Constructor for the SCORM 2004 cmi object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super();\n\n    this.learner_preference = new CMILearnerPreference();\n    this.score = new Scorm2004CMIScore();\n    this.comments_from_learner = new CMICommentsFromLearner();\n    this.comments_from_lms = new CMICommentsFromLMS();\n    this.interactions = new CMIInteractions();\n    this.objectives = new CMIObjectives();\n\n    if (initialized) this.initialize();\n  }\n\n  #_version = '1.0';\n  #_children = scorm2004_constants.cmi_children;\n  #completion_status = 'unknown';\n  #completion_threshold = '';\n  #credit = 'credit';\n  #entry = '';\n  #exit = '';\n  #launch_data = '';\n  #learner_id = '';\n  #learner_name = '';\n  #location = '';\n  #max_time_allowed = '';\n  #mode = 'normal';\n  #progress_measure = '';\n  #scaled_passing_score = '';\n  #session_time = 'PT0H0M0S';\n  #success_status = 'unknown';\n  #suspend_data = '';\n  #time_limit_action = 'continue,no message';\n  #total_time = '';\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.learner_preference?.initialize();\n    this.score?.initialize();\n    this.comments_from_learner?.initialize();\n    this.comments_from_lms?.initialize();\n    this.interactions?.initialize();\n    this.objectives?.initialize();\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   * @private\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   * @private\n   */\n  set _version(_version) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {number} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n      this.#completion_status = completion_status;\n    }\n  }\n\n  /**\n   * Getter for #completion_threshold\n   * @return {string}\n   */\n  get completion_threshold() {\n    return this.#completion_threshold;\n  }\n\n  /**\n   * Setter for #completion_threshold. Can only be called before  initialization.\n   * @param {string} completion_threshold\n   */\n  set completion_threshold(completion_threshold) {\n    !this.initialized ?\n      this.#completion_threshold = completion_threshold :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Setter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {string}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Getter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_id\n   * @return {string}\n   */\n  get learner_id() {\n    return this.#learner_id;\n  }\n\n  /**\n   * Setter for #learner_id. Can only be called before  initialization.\n   * @param {string} learner_id\n   */\n  set learner_id(learner_id) {\n    !this.initialized ? this.#learner_id = learner_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_name\n   * @return {string}\n   */\n  get learner_name() {\n    return this.#learner_name;\n  }\n\n  /**\n   * Setter for #learner_name. Can only be called before  initialization.\n   * @param {string} learner_name\n   */\n  set learner_name(learner_name) {\n    !this.initialized ?\n      this.#learner_name = learner_name :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) {\n      this.#location = location;\n    }\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n      this.#max_time_allowed = max_time_allowed :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #mode\n   * @return {string}\n   */\n  get mode() {\n    return this.#mode;\n  }\n\n  /**\n   * Setter for #mode. Can only be called before  initialization.\n   * @param {string} mode\n   */\n  set mode(mode) {\n    !this.initialized ? this.#mode = mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) {\n      this.#progress_measure = progress_measure;\n    }\n  }\n\n  /**\n   * Getter for #scaled_passing_score\n   * @return {string}\n   */\n  get scaled_passing_score() {\n    return this.#scaled_passing_score;\n  }\n\n  /**\n   * Setter for #scaled_passing_score. Can only be called before  initialization.\n   * @param {string} scaled_passing_score\n   */\n  set scaled_passing_score(scaled_passing_score) {\n    !this.initialized ?\n      this.#scaled_passing_score = scaled_passing_score :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {string}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n      this.#success_status = success_status;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000,\n        true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n      this.#time_limit_action = time_limit_action :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string} ISO8601 Duration\n   */\n  getCurrentTotalTime() {\n    let sessionTime = this.#session_time;\n    const startTime = this.start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsISODuration(seconds / 1000);\n    }\n\n    return Util.addTwoDurations(\n        this.#total_time,\n        sessionTime,\n        scorm2004_regex.CMITimespan,\n    );\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      comments_from_learner: CMICommentsFromLearner,\n   *      comments_from_lms: CMICommentsFromLMS,\n   *      completion_status: string,\n   *      completion_threshold: string,\n   *      credit: string,\n   *      entry: string,\n   *      exit: string,\n   *      interactions: CMIInteractions,\n   *      launch_data: string,\n   *      learner_id: string,\n   *      learner_name: string,\n   *      learner_preference: CMILearnerPreference,\n   *      location: string,\n   *      max_time_allowed: string,\n   *      mode: string,\n   *      objectives: CMIObjectives,\n   *      progress_measure: string,\n   *      scaled_passing_score: string,\n   *      score: Scorm2004CMIScore,\n   *      session_time: string,\n   *      success_status: string,\n   *      suspend_data: string,\n   *      time_limit_action: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comments_from_learner': this.comments_from_learner,\n      'comments_from_lms': this.comments_from_lms,\n      'completion_status': this.completion_status,\n      'completion_threshold': this.completion_threshold,\n      'credit': this.credit,\n      'entry': this.entry,\n      'exit': this.exit,\n      'interactions': this.interactions,\n      'launch_data': this.launch_data,\n      'learner_id': this.learner_id,\n      'learner_name': this.learner_name,\n      'learner_preference': this.learner_preference,\n      'location': this.location,\n      'max_time_allowed': this.max_time_allowed,\n      'mode': this.mode,\n      'objectives': this.objectives,\n      'progress_measure': this.progress_measure,\n      'scaled_passing_score': this.scaled_passing_score,\n      'score': this.score,\n      'session_time': this.session_time,\n      'success_status': this.success_status,\n      'suspend_data': this.suspend_data,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.learner_preference object\n */\nclass CMILearnerPreference extends BaseCMI {\n  #_children = scorm2004_constants.student_preference_children;\n  #audio_level = '1';\n  #language = '';\n  #delivery_speed = '1';\n  #audio_captioning = '0';\n\n  /**\n   * Constructor for cmi.learner_preference\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #audio_level\n   * @return {string}\n   */\n  get audio_level() {\n    return this.#audio_level;\n  }\n\n  /**\n   * Setter for #audio_level\n   * @param {string} audio_level\n   */\n  set audio_level(audio_level) {\n    if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(audio_level, scorm2004_regex.audio_range)) {\n      this.#audio_level = audio_level;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check2004ValidFormat(language, scorm2004_regex.CMILang)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #delivery_speed\n   * @return {string}\n   */\n  get delivery_speed() {\n    return this.#delivery_speed;\n  }\n\n  /**\n   * Setter for #delivery_speed\n   * @param {string} delivery_speed\n   */\n  set delivery_speed(delivery_speed) {\n    if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) {\n      this.#delivery_speed = delivery_speed;\n    }\n  }\n\n  /**\n   * Getter for #audio_captioning\n   * @return {string}\n   */\n  get audio_captioning() {\n    return this.#audio_captioning;\n  }\n\n  /**\n   * Setter for #audio_captioning\n   * @param {string} audio_captioning\n   */\n  set audio_captioning(audio_captioning) {\n    if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) &&\n      check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) {\n      this.#audio_captioning = audio_captioning;\n    }\n  }\n\n  /**\n   * toJSON for cmi.learner_preference\n   *\n   * @return {\n   *    {\n   *      audio_level: string,\n   *      language: string,\n   *      delivery_speed: string,\n   *      audio_captioning: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio_level': this.audio_level,\n      'language': this.language,\n      'delivery_speed': this.delivery_speed,\n      'audio_captioning': this.audio_captioning,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions object\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.interactions_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.objectives object\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.objectives_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_lms object\n */\nclass CMICommentsFromLMS extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_lms Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner object\n */\nclass CMICommentsFromLearner extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_learner Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.interaction.n object\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  #id = '';\n  #type = '';\n  #timestamp = '';\n  #weighting = '';\n  #learner_response = '';\n  #result = '';\n  #latency = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.interaction.n\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #type\n   * @return {string}\n   */\n  get type() {\n    return this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {\n        this.#type = type;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * Getter for #weighting\n   * @return {string}\n   */\n  get weighting() {\n    return this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {\n        this.#weighting = weighting;\n      }\n    }\n  }\n\n  /**\n   * Getter for #learner_response\n   * @return {string}\n   */\n  get learner_response() {\n    return this.#learner_response;\n  }\n\n  /**\n   * Setter for #learner_response. Does type validation to make sure response\n   * matches SCORM 2004's spec\n   * @param {string} learner_response\n   */\n  set learner_response(learner_response) {\n    if (this.initialized && (this.#type === '' || this.#id === '')) {\n      throwDependencyNotEstablishedError();\n    } else {\n      let nodes = [];\n      const response_type = learner_responses[this.type];\n      if (response_type) {\n        if (response_type?.delimiter) {\n          nodes = learner_response.split(response_type.delimiter);\n        } else {\n          nodes[0] = learner_response;\n        }\n\n        if ((nodes.length > 0) && (nodes.length <= response_type.max)) {\n          const formatRegex = new RegExp(response_type.format);\n          for (let i = 0; i < nodes.length; i++) {\n            if (response_type?.delimiter2) {\n              const values = nodes[i].split(response_type.delimiter2);\n              if (values.length === 2) {\n                if (!values[0].match(formatRegex)) {\n                  throwTypeMismatchError();\n                } else {\n                  if (!values[1].match(new RegExp(response_type.format2))) {\n                    throwTypeMismatchError();\n                  }\n                }\n              } else {\n                throwTypeMismatchError();\n              }\n            } else {\n              if (!nodes[i].match(formatRegex)) {\n                throwTypeMismatchError();\n              } else {\n                if (nodes[i] !== '' && response_type.unique) {\n                  for (let j = 0; j < i; j++) {\n                    if (nodes[i] === nodes[j]) {\n                      throwTypeMismatchError();\n                    }\n                  }\n                }\n              }\n            }\n          }\n        } else {\n          throwGeneralSetError();\n        }\n\n        this.#learner_response = learner_response;\n      } else {\n        throwTypeMismatchError();\n      }\n    }\n  }\n\n  /**\n   * Getter for #result\n   * @return {string}\n   */\n  get result() {\n    return this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency\n   * @return {string}\n   */\n  get latency() {\n    return this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {\n        this.#latency = latency;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      type: string,\n   *      objectives: CMIArray,\n   *      timestamp: string,\n   *      correct_responses: CMIArray,\n   *      weighting: string,\n   *      learner_response: string,\n   *      result: string,\n   *      latency: string,\n   *      description: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'type': this.type,\n      'objectives': this.objectives,\n      'timestamp': this.timestamp,\n      'weighting': this.weighting,\n      'learner_response': this.learner_response,\n      'result': this.result,\n      'latency': this.latency,\n      'description': this.description,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.objectives.n object\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  #id = '';\n  #success_status = 'unknown';\n  #completion_status = 'unknown';\n  #progress_measure = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new Scorm2004CMIScore();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n        this.#success_status = success_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n        this.#completion_status = completion_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n        check2004ValidRange(progress_measure,\n            scorm2004_regex.progress_range)) {\n        this.#progress_measure = progress_measure;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      success_status: string,\n   *      completion_status: string,\n   *      progress_measure: string,\n   *      description: string,\n   *      score: Scorm2004CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'success_status': this.success_status,\n      'completion_status': this.completion_status,\n      'progress_measure': this.progress_measure,\n      'description': this.description,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi *.score object\n */\nclass Scorm2004CMIScore extends CMIScore {\n  #scaled = '';\n\n  /**\n   * Constructor for cmi *.score\n   */\n  constructor() {\n    super(\n        {\n          score_children: scorm2004_constants.score_children,\n          max: '',\n          invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n          invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n          decimalRegex: scorm2004_regex.CMIDecimal,\n          errorClass: Scorm2004ValidationError,\n        });\n  }\n\n  /**\n   * Getter for #scaled\n   * @return {string}\n   */\n  get scaled() {\n    return this.#scaled;\n  }\n\n  /**\n   * Setter for #scaled\n   * @param {string} scaled\n   */\n  set scaled(scaled) {\n    if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(scaled, scorm2004_regex.scaled_range)) {\n      this.#scaled = scaled;\n    }\n  }\n\n  /**\n   * toJSON for cmi *.score\n   *\n   * @return {\n   *    {\n   *      scaled: string,\n   *      raw: string,\n   *      min: string,\n   *      max: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'scaled': this.scaled,\n      'raw': super.raw,\n      'min': super.min,\n      'max': super.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object\n */\nexport class CMICommentsObject extends BaseCMI {\n  #comment = '';\n  #location = '';\n  #timestamp = '';\n  #readOnlyAfterInit;\n\n  /**\n   * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n\n   * @param {boolean} readOnlyAfterInit\n   */\n  constructor(readOnlyAfterInit = false) {\n    super();\n    this.#comment = '';\n    this.#location = '';\n    this.#timestamp = '';\n    this.#readOnlyAfterInit = readOnlyAfterInit;\n  }\n\n  /**\n   * Getter for #comment\n   * @return {string}\n   */\n  get comment() {\n    return this.#comment;\n  }\n\n  /**\n   * Setter for #comment\n   * @param {string} comment\n   */\n  set comment(comment) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000,\n          true)) {\n        this.#comment = comment;\n      }\n    }\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {\n        this.#location = location;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.comments_from_learner.n object\n   * @return {\n   *    {\n   *      comment: string,\n   *      location: string,\n   *      timestamp: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comment': this.comment,\n      'location': this.location,\n      'timestamp': this.timestamp,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.objectives.n object\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  #id = '';\n\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  #pattern = '';\n\n  /**\n   * Constructor for cmi.interactions.n.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON cmi.interactions.n.correct_responses.n object\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl object\n */\nexport class ADL extends BaseCMI {\n  /**\n   * Constructor for adl\n   */\n  constructor() {\n    super();\n\n    this.nav = new ADLNav();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.nav?.initialize();\n  }\n\n  /**\n   * toJSON for adl\n   * @return {\n   *    {\n   *      nav: {\n   *        request: string\n   *      }\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'nav': this.nav,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav object\n */\nclass ADLNav extends BaseCMI {\n  #request = '_none_';\n\n  /**\n   * Constructor for adl.nav\n   */\n  constructor() {\n    super();\n\n    this.request_valid = new ADLNavRequestValid();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.request_valid?.initialize();\n  }\n\n  /**\n   * Getter for #request\n   * @return {string}\n   */\n  get request() {\n    return this.#request;\n  }\n\n  /**\n   * Setter for #request\n   * @param {string} request\n   */\n  set request(request) {\n    if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) {\n      this.#request = request;\n    }\n  }\n\n  /**\n   * toJSON for adl.nav\n   *\n   * @return {\n   *    {\n   *      request: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'request': this.request,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav.request_valid object\n */\nclass ADLNavRequestValid extends BaseCMI {\n  #continue = 'unknown';\n  #previous = 'unknown';\n  choice = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n  jump = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n\n  /**\n   * Constructor for adl.nav.request_valid\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #continue\n   * @return {string}\n   */\n  get continue() {\n    return this.#continue;\n  }\n\n  /**\n   * Setter for #continue. Just throws an error.\n   * @param {*} _\n   */\n  set continue(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #previous\n   * @return {string}\n   */\n  get previous() {\n    return this.#previous;\n  }\n\n  /**\n   * Setter for #previous. Just throws an error.\n   * @param {*} _\n   */\n  set previous(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for adl.nav.request_valid\n   *\n   * @return {\n   *    {\n   *      previous: string,\n   *      continue: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'previous': this.previous,\n      'continue': this.continue,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\n\nconst global = {\n  SCORM_TRUE: 'true',\n  SCORM_FALSE: 'false',\n  STATE_NOT_INITIALIZED: 0,\n  STATE_INITIALIZED: 1,\n  STATE_TERMINATED: 2,\n  LOG_LEVEL_DEBUG: 1,\n  LOG_LEVEL_INFO: 2,\n  LOG_LEVEL_WARNING: 3,\n  LOG_LEVEL_ERROR: 4,\n  LOG_LEVEL_NONE: 5,\n};\n\nconst scorm12 = {\n  // Children lists\n  cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',\n  core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',\n  score_children: 'raw,min,max',\n  comments_children: 'content,location,time',\n  objectives_children: 'id,score,status',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio,language,speed,text',\n  interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',\n\n  error_descriptions: {\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information',\n    },\n    '201': {\n      basicMessage: 'Invalid argument error',\n      detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.',\n    },\n    '202': {\n      basicMessage: 'Element cannot have children',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_children\" for a data model element that does not support the \"_children\" suffix.',\n    },\n    '203': {\n      basicMessage: 'Element not an array - cannot have count',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_count\" for a data model element that does not support the \"_count\" suffix.',\n    },\n    '301': {\n      basicMessage: 'Not initialized',\n      detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.',\n    },\n    '401': {\n      basicMessage: 'Not implemented error',\n      detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.',\n    },\n    '402': {\n      basicMessage: 'Invalid set value, element is a keyword',\n      detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in \"_children\" and \"_count\").',\n    },\n    '403': {\n      basicMessage: 'Element is read only',\n      detailMessage: 'LMSSetValue was called with a data model element that can only be read.',\n    },\n    '404': {\n      basicMessage: 'Element is write only',\n      detailMessage: 'LMSGetValue was called on a data model element that can only be written to.',\n    },\n    '405': {\n      basicMessage: 'Incorrect Data Type',\n      detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n    student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',\n    student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n    student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',\n    tries_children: 'time,status,score',\n    attempt_records_children: 'score,lesson_status',\n    paths_children: 'location_id,date,time,status,why_left,time_in_element',\n  },\n};\n\nconst scorm2004 = {\n  // Children lists\n  cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',\n  comments_children: 'comment,timestamp,location',\n  score_children: 'max,raw,scaled,min',\n  objectives_children: 'progress_measure,completion_status,success_status,description,score,id',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',\n  interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',\n\n  error_descriptions: {\n    '0': {\n      basicMessage: 'No Error',\n      detailMessage: 'No error occurred, the previous API call was successful.',\n    },\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.',\n    },\n    '102': {\n      basicMessage: 'General Initialization Failure',\n      detailMessage: 'Call to Initialize failed for an unknown reason.',\n    },\n    '103': {\n      basicMessage: 'Already Initialized',\n      detailMessage: 'Call to Initialize failed because Initialize was already called.',\n    },\n    '104': {\n      basicMessage: 'Content Instance Terminated',\n      detailMessage: 'Call to Initialize failed because Terminate was already called.',\n    },\n    '111': {\n      basicMessage: 'General Termination Failure',\n      detailMessage: 'Call to Terminate failed for an unknown reason.',\n    },\n    '112': {\n      basicMessage: 'Termination Before Initialization',\n      detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.',\n    },\n    '113': {\n      basicMessage: 'Termination After Termination',\n      detailMessage: 'Call to Terminate failed because Terminate was already called.',\n    },\n    '122': {\n      basicMessage: 'Retrieve Data Before Initialization',\n      detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.',\n    },\n    '123': {\n      basicMessage: 'Retrieve Data After Termination',\n      detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.',\n    },\n    '132': {\n      basicMessage: 'Store Data Before Initialization',\n      detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.',\n    },\n    '133': {\n      basicMessage: 'Store Data After Termination',\n      detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.',\n    },\n    '142': {\n      basicMessage: 'Commit Before Initialization',\n      detailMessage: 'Call to Commit failed because it was made before the call to Initialize.',\n    },\n    '143': {\n      basicMessage: 'Commit After Termination',\n      detailMessage: 'Call to Commit failed because it was made after the call to Terminate.',\n    },\n    '201': {\n      basicMessage: 'General Argument Error',\n      detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.',\n    },\n    '301': {\n      basicMessage: 'General Get Failure',\n      detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '351': {\n      basicMessage: 'General Set Failure',\n      detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '391': {\n      basicMessage: 'General Commit Failure',\n      detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '401': {\n      basicMessage: 'Undefined Data Model Element',\n      detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.',\n    },\n    '402': {\n      basicMessage: 'Unimplemented Data Model Element',\n      detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.',\n    },\n    '403': {\n      basicMessage: 'Data Model Element Value Not Initialized',\n      detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.',\n    },\n    '404': {\n      basicMessage: 'Data Model Element Is Read Only',\n      detailMessage: 'SetValue was called with a data model element that can only be read.',\n    },\n    '405': {\n      basicMessage: 'Data Model Element Is Write Only',\n      detailMessage: 'GetValue was called on a data model element that can only be written to.',\n    },\n    '406': {\n      basicMessage: 'Data Model Element Type Mismatch',\n      detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Data Model Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst APIConstants = {\n  global: global,\n  scorm12: scorm12,\n  aicc: aicc,\n  scorm2004: scorm2004,\n};\n\nexport default APIConstants;\n","// @flow\nconst global = {\n  GENERAL: 101,\n  INITIALIZATION_FAILED: 101,\n  INITIALIZED: 101,\n  TERMINATED: 101,\n  TERMINATION_FAILURE: 101,\n  TERMINATION_BEFORE_INIT: 101,\n  MULTIPLE_TERMINATION: 101,\n  RETRIEVE_BEFORE_INIT: 101,\n  RETRIEVE_AFTER_TERM: 101,\n  STORE_BEFORE_INIT: 101,\n  STORE_AFTER_TERM: 101,\n  COMMIT_BEFORE_INIT: 101,\n  COMMIT_AFTER_TERM: 101,\n  ARGUMENT_ERROR: 101,\n  CHILDREN_ERROR: 101,\n  COUNT_ERROR: 101,\n  GENERAL_GET_FAILURE: 101,\n  GENERAL_SET_FAILURE: 101,\n  GENERAL_COMMIT_FAILURE: 101,\n  UNDEFINED_DATA_MODEL: 101,\n  UNIMPLEMENTED_ELEMENT: 101,\n  VALUE_NOT_INITIALIZED: 101,\n  INVALID_SET_VALUE: 101,\n  READ_ONLY_ELEMENT: 101,\n  WRITE_ONLY_ELEMENT: 101,\n  TYPE_MISMATCH: 101,\n  VALUE_OUT_OF_RANGE: 101,\n  DEPENDENCY_NOT_ESTABLISHED: 101,\n};\n\nconst scorm12 = {\n  ...global, ...{\n    RETRIEVE_BEFORE_INIT: 301,\n    STORE_BEFORE_INIT: 301,\n    COMMIT_BEFORE_INIT: 301,\n    ARGUMENT_ERROR: 201,\n    CHILDREN_ERROR: 202,\n    COUNT_ERROR: 203,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 401,\n    VALUE_NOT_INITIALIZED: 301,\n    INVALID_SET_VALUE: 402,\n    READ_ONLY_ELEMENT: 403,\n    WRITE_ONLY_ELEMENT: 404,\n    TYPE_MISMATCH: 405,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst scorm2004 = {\n  ...global, ...{\n    INITIALIZATION_FAILED: 102,\n    INITIALIZED: 103,\n    TERMINATED: 104,\n    TERMINATION_FAILURE: 111,\n    TERMINATION_BEFORE_INIT: 112,\n    MULTIPLE_TERMINATIONS: 113,\n    RETRIEVE_BEFORE_INIT: 122,\n    RETRIEVE_AFTER_TERM: 123,\n    STORE_BEFORE_INIT: 132,\n    STORE_AFTER_TERM: 133,\n    COMMIT_BEFORE_INIT: 142,\n    COMMIT_AFTER_TERM: 143,\n    ARGUMENT_ERROR: 201,\n    GENERAL_GET_FAILURE: 301,\n    GENERAL_SET_FAILURE: 351,\n    GENERAL_COMMIT_FAILURE: 391,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 402,\n    VALUE_NOT_INITIALIZED: 403,\n    READ_ONLY_ELEMENT: 404,\n    WRITE_ONLY_ELEMENT: 405,\n    TYPE_MISMATCH: 406,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst ErrorCodes = {\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default ErrorCodes;\n","const ValidLanguages = {\n  'aa': 'aa', 'ab': 'ab', 'ae': 'ae', 'af': 'af', 'ak': 'ak', 'am': 'am',\n  'an': 'an', 'ar': 'ar', 'as': 'as', 'av': 'av', 'ay': 'ay', 'az': 'az',\n  'ba': 'ba', 'be': 'be', 'bg': 'bg', 'bh': 'bh', 'bi': 'bi', 'bm': 'bm',\n  'bn': 'bn', 'bo': 'bo', 'br': 'br', 'bs': 'bs', 'ca': 'ca', 'ce': 'ce',\n  'ch': 'ch', 'co': 'co', 'cr': 'cr', 'cs': 'cs', 'cu': 'cu', 'cv': 'cv',\n  'cy': 'cy', 'da': 'da', 'de': 'de', 'dv': 'dv', 'dz': 'dz', 'ee': 'ee',\n  'el': 'el', 'en': 'en', 'eo': 'eo', 'es': 'es', 'et': 'et', 'eu': 'eu',\n  'fa': 'fa', 'ff': 'ff', 'fi': 'fi', 'fj': 'fj', 'fo': 'fo', 'fr': 'fr',\n  'fy': 'fy', 'ga': 'ga', 'gd': 'gd', 'gl': 'gl', 'gn': 'gn', 'gu': 'gu',\n  'gv': 'gv', 'ha': 'ha', 'he': 'he', 'hi': 'hi', 'ho': 'ho', 'hr': 'hr',\n  'ht': 'ht', 'hu': 'hu', 'hy': 'hy', 'hz': 'hz', 'ia': 'ia', 'id': 'id',\n  'ie': 'ie', 'ig': 'ig', 'ii': 'ii', 'ik': 'ik', 'io': 'io', 'is': 'is',\n  'it': 'it', 'iu': 'iu', 'ja': 'ja', 'jv': 'jv', 'ka': 'ka', 'kg': 'kg',\n  'ki': 'ki', 'kj': 'kj', 'kk': 'kk', 'kl': 'kl', 'km': 'km', 'kn': 'kn',\n  'ko': 'ko', 'kr': 'kr', 'ks': 'ks', 'ku': 'ku', 'kv': 'kv', 'kw': 'kw',\n  'ky': 'ky', 'la': 'la', 'lb': 'lb', 'lg': 'lg', 'li': 'li', 'ln': 'ln',\n  'lo': 'lo', 'lt': 'lt', 'lu': 'lu', 'lv': 'lv', 'mg': 'mg', 'mh': 'mh',\n  'mi': 'mi', 'mk': 'mk', 'ml': 'ml', 'mn': 'mn', 'mo': 'mo', 'mr': 'mr',\n  'ms': 'ms', 'mt': 'mt', 'my': 'my', 'na': 'na', 'nb': 'nb', 'nd': 'nd',\n  'ne': 'ne', 'ng': 'ng', 'nl': 'nl', 'nn': 'nn', 'no': 'no', 'nr': 'nr',\n  'nv': 'nv', 'ny': 'ny', 'oc': 'oc', 'oj': 'oj', 'om': 'om', 'or': 'or',\n  'os': 'os', 'pa': 'pa', 'pi': 'pi', 'pl': 'pl', 'ps': 'ps', 'pt': 'pt',\n  'qu': 'qu', 'rm': 'rm', 'rn': 'rn', 'ro': 'ro', 'ru': 'ru', 'rw': 'rw',\n  'sa': 'sa', 'sc': 'sc', 'sd': 'sd', 'se': 'se', 'sg': 'sg', 'sh': 'sh',\n  'si': 'si', 'sk': 'sk', 'sl': 'sl', 'sm': 'sm', 'sn': 'sn', 'so': 'so',\n  'sq': 'sq', 'sr': 'sr', 'ss': 'ss', 'st': 'st', 'su': 'su', 'sv': 'sv',\n  'sw': 'sw', 'ta': 'ta', 'te': 'te', 'tg': 'tg', 'th': 'th', 'ti': 'ti',\n  'tk': 'tk', 'tl': 'tl', 'tn': 'tn', 'to': 'to', 'tr': 'tr', 'ts': 'ts',\n  'tt': 'tt', 'tw': 'tw', 'ty': 'ty', 'ug': 'ug', 'uk': 'uk', 'ur': 'ur',\n  'uz': 'uz', 've': 've', 'vi': 'vi', 'vo': 'vo', 'wa': 'wa', 'wo': 'wo',\n  'xh': 'xh', 'yi': 'yi', 'yo': 'yo', 'za': 'za', 'zh': 'zh', 'zu': 'zu',\n  'aar': 'aar', 'abk': 'abk', 'ave': 'ave', 'afr': 'afr', 'aka': 'aka',\n  'amh': 'amh', 'arg': 'arg', 'ara': 'ara', 'asm': 'asm', 'ava': 'ava',\n  'aym': 'aym', 'aze': 'aze', 'bak': 'bak', 'bel': 'bel', 'bul': 'bul',\n  'bih': 'bih', 'bis': 'bis', 'bam': 'bam', 'ben': 'ben', 'tib': 'tib',\n  'bod': 'bod', 'bre': 'bre', 'bos': 'bos', 'cat': 'cat', 'che': 'che',\n  'cha': 'cha', 'cos': 'cos', 'cre': 'cre', 'cze': 'cze', 'ces': 'ces',\n  'chu': 'chu', 'chv': 'chv', 'wel': 'wel', 'cym': 'cym', 'dan': 'dan',\n  'ger': 'ger', 'deu': 'deu', 'div': 'div', 'dzo': 'dzo', 'ewe': 'ewe',\n  'gre': 'gre', 'ell': 'ell', 'eng': 'eng', 'epo': 'epo', 'spa': 'spa',\n  'est': 'est', 'baq': 'baq', 'eus': 'eus', 'per': 'per', 'fas': 'fas',\n  'ful': 'ful', 'fin': 'fin', 'fij': 'fij', 'fao': 'fao', 'fre': 'fre',\n  'fra': 'fra', 'fry': 'fry', 'gle': 'gle', 'gla': 'gla', 'glg': 'glg',\n  'grn': 'grn', 'guj': 'guj', 'glv': 'glv', 'hau': 'hau', 'heb': 'heb',\n  'hin': 'hin', 'hmo': 'hmo', 'hrv': 'hrv', 'hat': 'hat', 'hun': 'hun',\n  'arm': 'arm', 'hye': 'hye', 'her': 'her', 'ina': 'ina', 'ind': 'ind',\n  'ile': 'ile', 'ibo': 'ibo', 'iii': 'iii', 'ipk': 'ipk', 'ido': 'ido',\n  'ice': 'ice', 'isl': 'isl', 'ita': 'ita', 'iku': 'iku', 'jpn': 'jpn',\n  'jav': 'jav', 'geo': 'geo', 'kat': 'kat', 'kon': 'kon', 'kik': 'kik',\n  'kua': 'kua', 'kaz': 'kaz', 'kal': 'kal', 'khm': 'khm', 'kan': 'kan',\n  'kor': 'kor', 'kau': 'kau', 'kas': 'kas', 'kur': 'kur', 'kom': 'kom',\n  'cor': 'cor', 'kir': 'kir', 'lat': 'lat', 'ltz': 'ltz', 'lug': 'lug',\n  'lim': 'lim', 'lin': 'lin', 'lao': 'lao', 'lit': 'lit', 'lub': 'lub',\n  'lav': 'lav', 'mlg': 'mlg', 'mah': 'mah', 'mao': 'mao', 'mri': 'mri',\n  'mac': 'mac', 'mkd': 'mkd', 'mal': 'mal', 'mon': 'mon', 'mol': 'mol',\n  'mar': 'mar', 'may': 'may', 'msa': 'msa', 'mlt': 'mlt', 'bur': 'bur',\n  'mya': 'mya', 'nau': 'nau', 'nob': 'nob', 'nde': 'nde', 'nep': 'nep',\n  'ndo': 'ndo', 'dut': 'dut', 'nld': 'nld', 'nno': 'nno', 'nor': 'nor',\n  'nbl': 'nbl', 'nav': 'nav', 'nya': 'nya', 'oci': 'oci', 'oji': 'oji',\n  'orm': 'orm', 'ori': 'ori', 'oss': 'oss', 'pan': 'pan', 'pli': 'pli',\n  'pol': 'pol', 'pus': 'pus', 'por': 'por', 'que': 'que', 'roh': 'roh',\n  'run': 'run', 'rum': 'rum', 'ron': 'ron', 'rus': 'rus', 'kin': 'kin',\n  'san': 'san', 'srd': 'srd', 'snd': 'snd', 'sme': 'sme', 'sag': 'sag',\n  'slo': 'slo', 'sin': 'sin', 'slk': 'slk', 'slv': 'slv', 'smo': 'smo',\n  'sna': 'sna', 'som': 'som', 'alb': 'alb', 'sqi': 'sqi', 'srp': 'srp',\n  'ssw': 'ssw', 'sot': 'sot', 'sun': 'sun', 'swe': 'swe', 'swa': 'swa',\n  'tam': 'tam', 'tel': 'tel', 'tgk': 'tgk', 'tha': 'tha', 'tir': 'tir',\n  'tuk': 'tuk', 'tgl': 'tgl', 'tsn': 'tsn', 'ton': 'ton', 'tur': 'tur',\n  'tso': 'tso', 'tat': 'tat', 'twi': 'twi', 'tah': 'tah', 'uig': 'uig',\n  'ukr': 'ukr', 'urd': 'urd', 'uzb': 'uzb', 'ven': 'ven', 'vie': 'vie',\n  'vol': 'vol', 'wln': 'wln', 'wol': 'wol', 'xho': 'xho', 'yid': 'yid',\n  'yor': 'yor', 'zha': 'zha', 'chi': 'chi', 'zho': 'zho', 'zul': 'zul',\n};\n\nexport default ValidLanguages;\n","// @flow\n\nconst scorm12 = {\n  CMIString256: '^.{0,255}$',\n  CMIString4096: '^.{0,4096}$',\n  CMITime: '^(?:[01]\\\\d|2[0123]):(?:[012345]\\\\d):(?:[012345]\\\\d)$', // eslint-disable-line\n  CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\\.[0-9]{1,2})?$', // eslint-disable-line\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{0,3})(\\.[0-9]*)?$', // eslint-disable-line\n  CMIIdentifier: '^[\\\\u0021-\\\\u007E\\\\s]{0,255}$',\n  CMIFeedback: '^.{0,255}$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',\n  CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',\n  CMIExit: '^(time-out|suspend|logout|)$',\n  CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',\n  CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\\\.[0-9]*)?)$', // eslint-disable-line\n  NAVEvent: '^(previous|continue)$',\n\n  // Data ranges\n  score_range: '0#100',\n  audio_range: '-1#100',\n  speed_range: '-100#100',\n  weighting_range: '-100#100',\n  text_range: '-1#1',\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    CMIIdentifier: '^\\\\w{1,255}$',\n  },\n};\n\nconst scorm2004 = {\n  CMIString200: '^[\\\\u0000-\\\\uFFFF]{0,200}$',\n  CMIString250: '^[\\\\u0000-\\\\uFFFF]{0,250}$',\n  CMIString1000: '^[\\\\u0000-\\\\uFFFF]{0,1000}$',\n  CMIString4000: '^[\\\\u0000-\\\\uFFFF]{0,4000}$',\n  CMIString64000: '^[\\\\u0000-\\\\uFFFF]{0,64000}$',\n  CMILang: '^([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?$|^$', // eslint-disable-line\n  CMILangString250: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,250}$)?$', // eslint-disable-line\n  CMILangcr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\}))(.*?)$', // eslint-disable-line\n  CMILangString250cr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\})?(.{0,250})?)?$', // eslint-disable-line\n  CMILangString4000: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,4000}$)?$', // eslint-disable-line\n  CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',\n  CMITimespan: '^P(?:([.,\\\\d]+)Y)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)W)?(?:([.,\\\\d]+)D)?(?:T?(?:([.,\\\\d]+)H)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)S)?)?$',\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{1,5})(\\\\.[0-9]{1,18})?$',\n  CMIIdentifier: '^\\\\S{1,250}[a-zA-Z0-9]$',\n  CMIShortIdentifier: '^[\\\\w\\\\.\\\\-\\\\_]{1,250}$', // eslint-disable-line\n  CMILongIdentifier: '^(?:(?!urn:)\\\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\\\S{1,4000}|.{1,4000})$', // need to re-examine this\n  CMIFeedback: '^.*$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n  CMIIndexStore: '.N(\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMICStatus: '^(completed|incomplete|not attempted|unknown)$',\n  CMISStatus: '^(passed|failed|unknown)$',\n  CMIExit: '^(time-out|suspend|logout|normal)$',\n  CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',\n  CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n  NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\\{target=\\\\S{0,200}[a-zA-Z0-9]\\}choice|jump)$', // eslint-disable-line\n  NAVBoolean: '^(unknown|true|false$)',\n  NAVTarget: '^(previous|continue|choice.{target=\\\\S{0,200}[a-zA-Z0-9]})$',\n\n  // Data ranges\n  scaled_range: '-1#1',\n  audio_range: '0#*',\n  speed_range: '0#*',\n  text_range: '-1#1',\n  progress_range: '0#1',\n};\n\nconst Regex = {\n  aicc: aicc,\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default Regex;\n","// @flow\nimport Regex from './regex';\n\nconst scorm2004_regex = Regex.scorm2004;\n\nconst learner = {\n  'true-false': {\n    format: '^true$|^false$',\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'choice': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n  },\n  'fill-in': {\n    format: scorm2004_regex.CMILangString250,\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'long-fill-in': {\n    format: scorm2004_regex.CMILangString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'matching': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'performance': {\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'sequencing': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'likert': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'numeric': {\n    format: scorm2004_regex.CMIDecimal,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'other': {\n    format: scorm2004_regex.CMIString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n};\n\nconst correct = {\n  'true-false': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: '^true$|^false$',\n    limit: 1,\n  },\n  'choice': {\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'fill-in': {\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMILangString250cr,\n  },\n  'long-fill-in': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: true,\n    format: scorm2004_regex.CMILangString4000,\n  },\n  'matching': {\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n  },\n  'performance': {\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n  },\n  'sequencing': {\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'likert': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    limit: 1,\n  },\n  'numeric': {\n    max: 2,\n    delimiter: '[:]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIDecimal,\n    limit: 1,\n  },\n  'other': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIString4000,\n    limit: 1,\n  },\n};\n\nconst Responses = {\n  learner: learner,\n  correct: correct,\n};\n\nexport default Responses;\n","// @flow\n\nimport APIConstants from './constants/api_constants';\n\nconst scorm12_errors = APIConstants.scorm12.error_descriptions;\nconst aicc_errors = APIConstants.aicc.error_descriptions;\nconst scorm2004_errors = APIConstants.scorm2004.error_descriptions;\n\n/**\n * Base Validation Exception\n */\nexport class ValidationError extends Error {\n  /**\n   * Constructor to take in an error message and code\n   * @param {number} errorCode\n   * @param {string} errorMessage\n   * @param {string} detailedMessage\n   */\n  constructor(errorCode: number, errorMessage: String, detailedMessage: String) {\n    super(errorMessage);\n    this.#errorCode = errorCode;\n    this.#errorMessage = errorMessage;\n    this.#detailedMessage = detailedMessage;\n  }\n\n  #errorCode;\n  #errorMessage;\n  #detailedMessage;\n\n  /**\n   * Getter for #errorCode\n   * @return {number}\n   */\n  get errorCode() {\n    return this.#errorCode;\n  }\n\n  /**\n   * Getter for #errorMessage\n   * @return {string}\n   */\n  get errorMessage() {\n    return this.#errorMessage;\n  }\n\n  /**\n   * Getter for #detailedMessage\n   * @return {string}\n   */\n  get detailedMessage() {\n    return this.#detailedMessage;\n  }\n}\n\n/**\n * SCORM 1.2 Validation Error\n */\nexport class Scorm12ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {\n      super(errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * AICC Validation Error\n */\nexport class AICCValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {\n      super(errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * SCORM 2004 Validation Error\n */\nexport class Scorm2004ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {\n      super(errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);\n    }\n  }\n}\n","import Scorm2004API from '../Scorm2004API';\n\nwindow.Scorm2004API = Scorm2004API;\n","// @flow\nexport const SECONDS_PER_SECOND = 1.0;\nexport const SECONDS_PER_MINUTE = 60;\nexport const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;\nexport const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;\n\nconst designations = [\n  ['D', SECONDS_PER_DAY],\n  ['H', SECONDS_PER_HOUR],\n  ['M', SECONDS_PER_MINUTE],\n  ['S', SECONDS_PER_SECOND],\n];\n\n/**\n * Converts a Number to a String of HH:MM:SS\n *\n * @param {Number} totalSeconds\n * @return {string}\n */\nexport function getSecondsAsHHMMSS(totalSeconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!totalSeconds || totalSeconds <= 0) {\n    return '00:00:00';\n  }\n\n  const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);\n\n  const dateObj = new Date(totalSeconds * 1000);\n  const minutes = dateObj.getUTCMinutes();\n  // make sure we add any possible decimal value\n  const seconds = dateObj.getSeconds();\n  const ms = totalSeconds % 1.0;\n  let msStr = '';\n  if (countDecimals(ms) > 0) {\n    if (countDecimals(ms) > 2) {\n      msStr = ms.toFixed(2);\n    } else {\n      msStr = String(ms);\n    }\n    msStr = '.' + msStr.split('.')[1];\n  }\n\n  return (hours + ':' + minutes + ':' + seconds).replace(/\\b\\d\\b/g,\n      '0$&') + msStr;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {Number} seconds\n * @return {String}\n */\nexport function getSecondsAsISODuration(seconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!seconds || seconds <= 0) {\n    return 'PT0S';\n  }\n\n  let duration = 'P';\n  let remainder = seconds;\n\n  designations.forEach(([sign, current_seconds]) => {\n    let value = Math.floor(remainder / current_seconds);\n\n    remainder = remainder % current_seconds;\n    if (countDecimals(remainder) > 2) {\n      remainder = Number(Number(remainder).toFixed(2));\n    }\n    // If we have anything left in the remainder, and we're currently adding\n    // seconds to the duration, go ahead and add the decimal to the seconds\n    if (sign === 'S' && remainder > 0) {\n      value += remainder;\n    }\n\n    if (value) {\n      if ((duration.indexOf('D') > 0 ||\n          sign === 'H' || sign === 'M' || sign === 'S') &&\n          duration.indexOf('T') === -1) {\n        duration += 'T';\n      }\n      duration += `${value}${sign}`;\n    }\n  });\n\n  return duration;\n}\n\n/**\n * Calculate the number of seconds from HH:MM:SS.DDDDDD\n *\n * @param {string} timeString\n * @param {RegExp} timeRegex\n * @return {number}\n */\nexport function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {\n  if (!timeString || typeof timeString !== 'string' ||\n      !timeString.match(timeRegex)) {\n    return 0;\n  }\n  const parts = timeString.split(':');\n  const hours = Number(parts[0]);\n  const minutes = Number(parts[1]);\n  const seconds = Number(parts[2]);\n  return (hours * 3600) + (minutes * 60) + seconds;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {string} duration\n * @param {RegExp} durationRegex\n * @return {number}\n */\nexport function getDurationAsSeconds(duration: String, durationRegex: RegExp) {\n  if (!duration || !duration.match(durationRegex)) {\n    return 0;\n  }\n\n  const [, years, months, , days, hours, minutes, seconds] = new RegExp(\n      durationRegex).exec(duration) || [];\n\n  let result = 0.0;\n\n  result += (Number(seconds) * 1.0 || 0.0);\n  result += (Number(minutes) * 60.0 || 0.0);\n  result += (Number(hours) * 3600.0 || 0.0);\n  result += (Number(days) * (60 * 60 * 24.0) || 0.0);\n  result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);\n\n  return result;\n}\n\n/**\n * Adds together two ISO8601 Duration strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} durationRegex\n * @return {string}\n */\nexport function addTwoDurations(\n    first: String,\n    second: String,\n    durationRegex: RegExp) {\n  return getSecondsAsISODuration(\n      getDurationAsSeconds(first, durationRegex) +\n      getDurationAsSeconds(second, durationRegex),\n  );\n}\n\n/**\n * Add together two HH:MM:SS.DD strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} timeRegex\n * @return {string}\n */\nexport function addHHMMSSTimeStrings(\n    first: String,\n    second: String,\n    timeRegex: RegExp) {\n  return getSecondsAsHHMMSS(\n      getTimeAsSeconds(first, timeRegex) +\n      getTimeAsSeconds(\n          second, timeRegex),\n  );\n}\n\n/**\n * Flatten a JSON object down to string paths for each values\n * @param {object} data\n * @return {object}\n */\nexport function flatten(data) {\n  const result = {};\n\n  /**\n   * Recurse through the object\n   * @param {*} cur\n   * @param {*} prop\n   */\n  function recurse(cur, prop) {\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (let i = 0, l = cur.length; i < l; i++) {\n        recurse(cur[i], prop + '[' + i + ']');\n        if (l === 0) result[prop] = [];\n      }\n    } else {\n      let isEmpty = true;\n      for (const p in cur) {\n        if ({}.hasOwnProperty.call(cur, p)) {\n          isEmpty = false;\n          recurse(cur[p], prop ? prop + '.' + p : p);\n        }\n      }\n      if (isEmpty && prop) result[prop] = {};\n    }\n  }\n\n  recurse(data, '');\n  return result;\n}\n\n/**\n * Un-flatten a flat JSON object\n * @param {object} data\n * @return {object}\n */\nexport function unflatten(data) {\n  'use strict';\n  if (Object(data) !== data || Array.isArray(data)) return data;\n  const regex = /\\.?([^.[\\]]+)|\\[(\\d+)]/g;\n  const result = {};\n  for (const p in data) {\n    if ({}.hasOwnProperty.call(data, p)) {\n      let cur = result;\n      let prop = '';\n      let m = regex.exec(p);\n      while (m) {\n        cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));\n        prop = m[2] || m[1];\n        m = regex.exec(p);\n      }\n      cur[prop] = data[p];\n    }\n  }\n  return result[''] || result;\n}\n\n/**\n * Counts the number of decimal places\n * @param {number} num\n * @return {number}\n */\nexport function countDecimals(num: number) {\n  if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;\n  const parts = num.toString().split('.')[1];\n  return parts.length || 0;\n}\n"]}
|