scorm-again 3.0.4 → 3.0.5

package/dist/scorm-again.js

@@ -1159,6 +1159,11 @@
     progress_range: "0#1"
   };
 
+  const PERFORMANCE_STEP_NAME = "^$|" + scorm2004_regex.CMIShortIdentifier;
+  const PERFORMANCE_CHARACTERSTRING = "(?![\\s\\S]*(?:\\[,\\]|\\[\\.\\]|\\[:\\]))[\\s\\S]{1,250}";
+  const PERFORMANCE_NUMERIC_RANGE = "(?:-?\\d+(?:\\.\\d+)?)?\\[:\\](?:-?\\d+(?:\\.\\d+)?)?";
+  const CR_PERFORMANCE_STEP_ANSWER = "^(?:|" + PERFORMANCE_NUMERIC_RANGE + "|" + PERFORMANCE_CHARACTERSTRING + ")$";
+  const LR_PERFORMANCE_STEP_ANSWER = "^(?:|" + PERFORMANCE_CHARACTERSTRING + ")$";
   const LearnerResponses = {
     "true-false": {
       format: "^true$|^false$",
@@ -1193,8 +1198,8 @@
       unique: false
     },
     performance: {
-      format: "^$|" + scorm2004_regex.CMIShortIdentifier,
-      format2: scorm2004_regex.CMIDecimal + "|^$|" + scorm2004_regex.CMIShortIdentifier,
+      format: PERFORMANCE_STEP_NAME,
+      format2: LR_PERFORMANCE_STEP_ANSWER,
       max: 250,
       delimiter: "[,]",
       delimiter2: "[.]",
@@ -1270,10 +1275,10 @@
       delimiter2: "[.]",
       unique: false,
       duplicate: false,
-      // step_name must be a non-empty short identifier
-      format: scorm2004_regex.CMIShortIdentifier,
-      // step_answer may be short identifier or numeric range (<decimal>[:<decimal>])
-      format2: `^(${scorm2004_regex.CMIShortIdentifier})$|^(?:\\d+(?:\\.\\d+)?(?::\\d+(?:\\.\\d+)?)?)$`
+      // step_name: optional short_identifier_type
+      format: PERFORMANCE_STEP_NAME,
+      // step_answer: optional characterstring (spaces allowed) or numeric range
+      format2: CR_PERFORMANCE_STEP_ANSWER
     },
     sequencing: {
       max: 36,
@@ -5298,7 +5303,13 @@
       if (!scorm2004) {
         if (isFinalAttribute) {
           if (typeof attribute === "undefined" || !this.context.checkObjectHasProperty(refObject, attribute)) {
-            this.context.throwSCORMError(CMIElement, invalidErrorCode, invalidErrorMessage);
+            if (attribute === "_children") {
+              this.context.throwSCORMError(CMIElement, getErrorCode(this.context.errorCodes, "CHILDREN_ERROR"));
+            } else if (attribute === "_count") {
+              this.context.throwSCORMError(CMIElement, getErrorCode(this.context.errorCodes, "COUNT_ERROR"));
+            } else {
+              this.context.throwSCORMError(CMIElement, invalidErrorCode, invalidErrorMessage);
+            }
             return {
               error: true
             };
@@ -15552,19 +15563,20 @@ ${stackTrace}`);
         if (errorCode === 143) returnValue = global_constants.SCORM_FALSE;
       } else {
         const result = this.storeData(false);
-        if ((result.errorCode ?? 0) > 0) {
+        const errorCode = result.errorCode ?? 0;
+        if (errorCode > 0) {
           if (result.errorMessage) {
             this.apiLog("commit", `Commit failed with error: ${result.errorMessage}`, LogLevelEnum.ERROR);
           }
           if (result.errorDetails) {
             this.apiLog("commit", `Error details: ${JSON.stringify(result.errorDetails)}`, LogLevelEnum.DEBUG);
           }
-          this.throwSCORMError("api", result.errorCode);
+          this.throwSCORMError("api", errorCode);
         }
         const resultValue = result?.result ?? global_constants.SCORM_FALSE;
         returnValue = typeof resultValue === "boolean" ? String(resultValue) : resultValue;
         this.apiLog(callbackName, " Result: " + returnValue, LogLevelEnum.DEBUG, "HttpRequest");
-        if (checkTerminated) this.lastErrorCode = "0";
+        if (checkTerminated && errorCode === 0) this.lastErrorCode = "0";
         this.processListeners(callbackName);
         if (this.settings.enableOfflineSupport && this._offlineStorageService && this._offlineStorageService.isDeviceOnline() && this._courseId) {
           this._offlineStorageService.hasPendingOfflineData(this._courseId).then(hasPendingData => {
@@ -18349,6 +18361,49 @@ ${stackTrace}`);
     }
   }
 
+  function stripBrackets(delim) {
+    return delim.replace(/[[\]]/g, "");
+  }
+  function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function splitDelimited(value, bracketed) {
+    if (!bracketed) {
+      return [value];
+    }
+    if (value.includes(bracketed)) {
+      return value.split(bracketed);
+    }
+    const bare = stripBrackets(bracketed);
+    if (!bare) {
+      return [value];
+    }
+    const splitRe = new RegExp(`(?<!\\\\)${escapeRegex(bare)}`, "g");
+    const unescapeRe = new RegExp(`\\\\${escapeRegex(bare)}`, "g");
+    return value.split(splitRe).map(part => part.replace(unescapeRe, bare));
+  }
+  function splitFirstDelimited(value, bracketed) {
+    if (!bracketed) {
+      return [value];
+    }
+    if (value.includes(bracketed)) {
+      const idx = value.indexOf(bracketed);
+      return [value.slice(0, idx), value.slice(idx + bracketed.length)];
+    }
+    const bare = stripBrackets(bracketed);
+    if (!bare) {
+      return [value];
+    }
+    const splitRe = new RegExp(`(?<!\\\\)${escapeRegex(bare)}`);
+    const unescapeRe = new RegExp(`\\\\${escapeRegex(bare)}`, "g");
+    const parts = value.split(splitRe);
+    const first = (parts[0] ?? "").replace(unescapeRe, bare);
+    if (parts.length === 1) {
+      return [first];
+    }
+    return [first, parts.slice(1).join(bare).replace(unescapeRe, bare)];
+  }
+
   var __defProp$l = Object.defineProperty;
   var __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, {
     enumerable: true,
@@ -18544,8 +18599,7 @@ ${stackTrace}`);
         const response_type = LearnerResponses[this.type];
         if (response_type) {
           if (response_type?.delimiter) {
-            const delimiter = response_type.delimiter === "[,]" ? "," : response_type.delimiter;
-            nodes = learner_response.split(delimiter);
+            nodes = splitDelimited(learner_response, response_type.delimiter);
           } else {
             nodes[0] = learner_response;
           }
@@ -18553,10 +18607,10 @@ ${stackTrace}`);
             const formatRegex = new RegExp(response_type.format);
             for (let i = 0; i < nodes.length; i++) {
               if (response_type?.delimiter2) {
-                const delimiter2 = response_type.delimiter2 === "[.]" ? "." : response_type.delimiter2;
-                const values = nodes[i]?.split(delimiter2);
+                const node = nodes[i] ?? "";
+                const values = this.type === "performance" ? splitFirstDelimited(node, response_type.delimiter2) : splitDelimited(node, response_type.delimiter2);
                 if (values?.length === 2) {
-                  if (this.type === "performance" && (values[0] === "" || values[1] === "")) {
+                  if (this.type === "performance" && values[0] === "" && values[1] === "") {
                     throw new Scorm2004ValidationError(this._cmi_element + ".learner_response", scorm2004_errors.TYPE_MISMATCH);
                   }
                   if (!values[0]?.match(formatRegex)) {
@@ -18737,37 +18791,19 @@ ${stackTrace}`);
       return result;
     }
   }
-  function stripBrackets(delim) {
-    return delim.replace(/[[\]]/g, "");
-  }
-  function escapeRegex(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  function splitUnescaped(text, delim) {
-    const reDelim = escapeRegex(delim);
-    const splitRe = new RegExp(`(?<!\\\\)${reDelim}`, "g");
-    const unescapeRe = new RegExp(`\\\\${reDelim}`, "g");
-    return text.split(splitRe).map(part => part.replace(unescapeRe, delim));
-  }
-  function splitFirstUnescaped(text, delim) {
-    const reDelim = escapeRegex(delim);
-    const splitRe = new RegExp(`(?<!\\\\)${reDelim}`);
-    const unescapeRe = new RegExp(`\\\\${reDelim}`, "g");
-    const parts = text.split(splitRe);
-    const firstPart = parts[0] ?? "";
-    if (parts.length === 1) {
-      return [firstPart.replace(unescapeRe, delim)];
+  const RESPONSE_PREFIX_RE = /^\{(?:lang|case_matters|order_matters)=[^}]+\}/;
+  function stripResponsePrefixes(node) {
+    let result = node;
+    while (RESPONSE_PREFIX_RE.test(result)) {
+      result = result.replace(RESPONSE_PREFIX_RE, "");
     }
-    const part1 = firstPart.replace(unescapeRe, delim);
-    const part2 = parts.slice(1).join(delim).replace(unescapeRe, delim);
-    return [part1, part2];
+    return result;
   }
   function validatePattern(type, pattern, responseDef) {
     if (pattern.trim() !== pattern) {
       throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
     }
-    const subDelim1 = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : null;
-    const rawNodes = subDelim1 ? splitUnescaped(pattern, subDelim1) : [pattern];
+    const rawNodes = responseDef.delimiter ? splitDelimited(pattern, responseDef.delimiter) : [pattern];
     for (const raw of rawNodes) {
       if (raw.trim() !== raw) {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
@@ -18776,17 +18812,11 @@ ${stackTrace}`);
     if (type === "fill-in" && pattern === "") {
       return;
     }
-    const delim1 = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : null;
-    let nodes;
-    if (delim1) {
-      nodes = splitUnescaped(pattern, delim1);
-    } else {
-      nodes = [pattern];
-    }
+    const nodes = responseDef.delimiter ? splitDelimited(pattern, responseDef.delimiter) : [pattern];
     if (!responseDef.delimiter && pattern.includes(",")) {
       throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
     }
-    if (responseDef.unique || responseDef.duplicate === false) {
+    if (type !== "numeric" && (responseDef.unique || responseDef.duplicate === false)) {
       const seen = new Set(nodes);
       if (seen.size !== nodes.length) {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
@@ -18806,8 +18836,7 @@ ${stackTrace}`);
       if (!delimBracketed) {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
       }
-      const delim = stripBrackets(delimBracketed);
-      const parts = value.split(new RegExp(`(?<!\\\\)${escapeRegex(delim)}`, "g")).map(n => n.replace(new RegExp(`\\\\${escapeRegex(delim)}`, "g"), delim));
+      const parts = splitDelimited(value, delimBracketed);
       if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
         throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
       }
@@ -18819,12 +18848,14 @@ ${stackTrace}`);
       switch (type) {
         case "numeric":
           {
-            const numDelim = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : ":";
-            const nums = node.split(numDelim);
-            if (nums.length < 1 || nums.length > 2) {
-              throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
+            if (node === "") {
+              const bracketedRange = nodes.length >= 2 && !!responseDef.delimiter && pattern.includes(responseDef.delimiter);
+              if (!bracketedRange) {
+                throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
+              }
+              break;
             }
-            nums.forEach(checkSingle);
+            checkSingle(node);
             break;
           }
         case "performance":
@@ -18833,13 +18864,13 @@ ${stackTrace}`);
             if (!delimBracketed) {
               throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
             }
-            const delim = stripBrackets(delimBracketed);
-            const parts = splitFirstUnescaped(node, delim);
+            const record = stripResponsePrefixes(node);
+            const parts = splitFirstDelimited(record, delimBracketed);
             if (parts.length !== 2) {
               throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
             }
             const [part1, part2] = parts;
-            if (part1 === "" || part2 === "" || part1 === part2) {
+            if (part1 === "" && part2 === "") {
               throw new Scorm2004ValidationError("cmi.interactions.n.correct_responses.n.pattern", scorm2004_errors.TYPE_MISMATCH);
             }
             if (part1 === void 0 || !fmt1.test(part1)) {
@@ -21625,7 +21656,7 @@ ${stackTrace}`);
     checkValidResponseType(CMIElement, response_type, value, interaction_type) {
       let nodes = [];
       if (response_type?.delimiter) {
-        nodes = String(value).split(response_type.delimiter);
+        nodes = splitDelimited(String(value), response_type.delimiter);
       } else {
         nodes[0] = value;
       }
@@ -21723,26 +21754,33 @@ ${stackTrace}`);
           nodes[i] = this.removeCorrectResponsePrefixes(CMIElement, nodes[i]);
         }
         if (response?.delimiter2) {
-          const values = nodes[i].split(response.delimiter2);
+          const values = interaction_type === "performance" ? splitFirstDelimited(nodes[i], response.delimiter2) : splitDelimited(nodes[i], response.delimiter2);
           if (values.length === 2) {
-            const matches = values[0].match(formatRegex);
-            if (!matches) {
+            if (interaction_type === "performance" && values[0] === "" && values[1] === "") {
               this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
             } else {
-              if (!response.format2 || !values[1].match(new RegExp(response.format2))) {
+              const matches = values[0]?.match(formatRegex);
+              if (!matches) {
                 this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
+              } else {
+                if (!response.format2 || !values[1]?.match(new RegExp(response.format2))) {
+                  this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
+                }
               }
             }
           } else {
             this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
           }
         } else {
+          if (interaction_type === "numeric" && nodes.length > 1 && nodes[i] === "" && !!response.delimiter && String(value).includes(response.delimiter)) {
+            continue;
+          }
           const matches = nodes[i].match(formatRegex);
           if (!matches && value !== "" || !matches && interaction_type === "true-false") {
             this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
           } else {
             if (interaction_type === "numeric" && nodes.length > 1) {
-              if (Number(nodes[0]) > Number(nodes[1])) {
+              if (nodes[0] !== "" && nodes[1] !== "" && Number(nodes[0]) > Number(nodes[1])) {
                 this.context.throwSCORMError(CMIElement, scorm2004_errors.TYPE_MISMATCH, `${interaction_type}: ${value}`);
               }
             } else {