@doenet/v06-to-v07 0.7.25-dev.533 → 0.7.25-dev.535

package/{index-6Spw9Yfi.js → index-Bin7pIAp.js}

@@ -47272,7 +47272,7 @@ async function cidFromArrayBuffer(data) {
       await crypto.subtle.digest("SHA-256", new Uint8Array());
       digest = (data2) => crypto.subtle.digest("SHA-256", data2);
     } catch (e22) {
-      const sha256 = (await import("./sha256-DT5xJ2Hv-DKty3xQ2-KH0qtYEU.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-DT5xJ2Hv-BVeLgYWQ-CHOh3hgV.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -74769,12 +74769,69 @@ function returnLocalizedDefaultStateVariableDefinition({
     }
   };
 }
+const BLANK_PLACEHOLDER = "＿";
+function latexWithBlanksAsPlaceholders(latex) {
+  return latex.split(MATH_BLANK_LATEX).join(BLANK_PLACEHOLDER);
+}
+function convertLatexWithBlanks(latex, convert) {
+  return convert(latexWithBlanksAsPlaceholders(latex));
+}
+function embeddedChildContent(child) {
+  const sv = child?.stateValues ?? {};
+  if (typeof sv.latex === "string") {
+    return sv.latex.trim();
+  }
+  if (typeof sv.text === "string") {
+    return sv.text.trim();
+  }
+  if (Array.isArray(sv.selectedValues)) {
+    return sv.selectedValues.map(
+      (value) => typeof value?.toLatex === "function" ? value.toLatex() : String(value ?? "")
+    ).filter((value) => value.trim() !== "").join(", ");
+  }
+  return "";
+}
 function returnScoredContainerAncestorDependency(...variableNames) {
   return {
     dependencyType: "ancestor",
     variableNames
   };
 }
+function mathTreeIsBlank(tree) {
+  if (tree === BLANK_PLACEHOLDER) {
+    return true;
+  }
+  if (Array.isArray(tree) && tree[0] === "matrix") {
+    return matrixEntriesAreBlank(tree[2]);
+  }
+  return false;
+}
+function matrixEntriesAreBlank(tuple2) {
+  return Array.isArray(tuple2) && tuple2[0] === "tuple" && tuple2.slice(1).every(
+    (entry) => entry === BLANK_PLACEHOLDER || matrixEntriesAreBlank(entry)
+  );
+}
+function responseIsBlank(response) {
+  if (response === null || response === void 0) {
+    return true;
+  }
+  if (typeof response === "string") {
+    return response.trim() === "";
+  }
+  if (typeof response === "number") {
+    return Number.isNaN(response);
+  }
+  if (Array.isArray(response)) {
+    return response.every(responseIsBlank);
+  }
+  if (typeof response === "object" && "tree" in response) {
+    return mathTreeIsBlank(response.tree);
+  }
+  return false;
+}
+function submittedResponsesAreBlank(submittedResponses) {
+  return submittedResponses.every(responseIsBlank);
+}
 function returnStandardAnswerAttributes() {
   return {
     weight: {
@@ -75056,6 +75113,49 @@ function returnStandardAnswerStateVariableDefinition() {
       };
     }
   };
+  stateVariableDefinitions.creditAchievedForProgress = {
+    description: "The credit this answer contributes when deciding whether the content around it has been completed, as a `<cascade>` does. Equal to `creditAchieved`, except that a hand-graded answer counts as fully correct once a non-blank response has been submitted.",
+    stateVariablesDeterminingDependencies: ["handGraded"],
+    returnDependencies({ stateValues }) {
+      const dependencies2 = {
+        handGraded: {
+          dependencyType: "stateVariable",
+          variableName: "handGraded"
+        }
+      };
+      if (stateValues.handGraded) {
+        dependencies2.responseHasBeenSubmitted = {
+          dependencyType: "stateVariable",
+          variableName: "responseHasBeenSubmitted"
+        };
+        dependencies2.submittedResponses = {
+          dependencyType: "stateVariable",
+          variableName: "submittedResponses"
+        };
+      } else {
+        dependencies2.creditAchieved = {
+          dependencyType: "stateVariable",
+          variableName: "creditAchieved"
+        };
+      }
+      return dependencies2;
+    },
+    definition({ dependencyValues }) {
+      if (!dependencyValues.handGraded) {
+        return {
+          setValue: {
+            creditAchievedForProgress: dependencyValues.creditAchieved
+          }
+        };
+      }
+      const responded = dependencyValues.responseHasBeenSubmitted && !submittedResponsesAreBlank(
+        dependencyValues.submittedResponses
+      );
+      return {
+        setValue: { creditAchievedForProgress: responded ? 1 : 0 }
+      };
+    }
+  };
   stateVariableDefinitions.autoSubmit = {
     returnDependencies: () => ({
       autoSubmit: {
@@ -83383,6 +83483,43 @@ class MathList extends CompositeComponent {
     return { replacementChanges, diagnostics: diagnostics2, nComponents };
   }
 }
+function returnAggregateCreditDependencies(variableName) {
+  return function({ stateValues }) {
+    const dependencies2 = {
+      aggregateScores: {
+        dependencyType: "stateVariable",
+        variableName: "aggregateScores"
+      }
+    };
+    if (stateValues.aggregateScores) {
+      dependencies2.scoredDescendants = {
+        dependencyType: "stateVariable",
+        variableName: "scoredDescendants"
+      };
+      for (let [
+        ind,
+        descendant
+      ] of stateValues.scoredDescendants.entries()) {
+        dependencies2[variableName + ind] = {
+          dependencyType: "stateVariable",
+          componentIdx: descendant.componentIdx,
+          variableName
+        };
+      }
+    }
+    return dependencies2;
+  };
+}
+function aggregateCreditOverScoredDescendants(dependencyValues, variableName, creditWhenNothingScored = 1) {
+  let creditSum = 0;
+  let totalWeight = 0;
+  for (let [ind, component] of dependencyValues.scoredDescendants.entries()) {
+    const weight = component.stateValues.weight;
+    creditSum += dependencyValues[variableName + ind] * weight;
+    totalWeight += weight;
+  }
+  return totalWeight > 0 ? creditSum / totalWeight : creditWhenNothingScored;
+}
 function returnScoredSectionAttributes() {
   return {
     aggregateScores: {
@@ -83791,31 +83928,7 @@ function returnScoredSectionStateVariableDefinition() {
       "aggregateScores",
       "scoredDescendants"
     ],
-    returnDependencies({ stateValues }) {
-      let dependencies2 = {
-        aggregateScores: {
-          dependencyType: "stateVariable",
-          variableName: "aggregateScores"
-        }
-      };
-      if (stateValues.aggregateScores) {
-        dependencies2.scoredDescendants = {
-          dependencyType: "stateVariable",
-          variableName: "scoredDescendants"
-        };
-        for (let [
-          ind,
-          descendant
-        ] of stateValues.scoredDescendants.entries()) {
-          dependencies2["creditAchieved" + ind] = {
-            dependencyType: "stateVariable",
-            componentIdx: descendant.componentIdx,
-            variableName: "creditAchieved"
-          };
-        }
-      }
-      return dependencies2;
-    },
+    returnDependencies: returnAggregateCreditDependencies("creditAchieved"),
     definition({ dependencyValues }) {
       if (!dependencyValues.aggregateScores) {
         return {
@@ -83825,57 +83938,51 @@ function returnScoredSectionStateVariableDefinition() {
           }
         };
       }
-      let creditSum = 0;
-      let totalWeight = 0;
-      for (let [
-        ind,
-        component
-      ] of dependencyValues.scoredDescendants.entries()) {
-        let weight = component.stateValues.weight;
-        creditSum += dependencyValues["creditAchieved" + ind] * weight;
-        totalWeight += weight;
-      }
-      let creditAchieved;
-      if (totalWeight > 0) {
-        creditAchieved = creditSum / totalWeight;
-      } else {
-        creditAchieved = 1;
-      }
-      let percentCreditAchieved = creditAchieved * 100;
-      return { setValue: { creditAchieved, percentCreditAchieved } };
+      const creditAchieved = aggregateCreditOverScoredDescendants(
+        dependencyValues,
+        "creditAchieved"
+      );
+      return {
+        setValue: {
+          creditAchieved,
+          percentCreditAchieved: creditAchieved * 100
+        }
+      };
     }
   };
-  stateVariableDefinitions.creditAchievedIfSubmit = {
+  stateVariableDefinitions.creditAchievedForProgress = {
+    description: "Aggregate credit achieved (between 0 and 1) for scored descendants of this section, used when deciding whether the section has been completed. Differs from `creditAchieved` only in that a hand-graded answer counts as fully correct once a non-blank response has been submitted.",
     defaultValue: 0,
     stateVariablesDeterminingDependencies: [
       "aggregateScores",
       "scoredDescendants"
     ],
-    returnDependencies({ stateValues }) {
-      let dependencies2 = {
-        aggregateScores: {
-          dependencyType: "stateVariable",
-          variableName: "aggregateScores"
+    returnDependencies: returnAggregateCreditDependencies(
+      "creditAchievedForProgress"
+    ),
+    definition({ dependencyValues }) {
+      if (!dependencyValues.aggregateScores) {
+        return { setValue: { creditAchievedForProgress: 0 } };
+      }
+      return {
+        setValue: {
+          creditAchievedForProgress: aggregateCreditOverScoredDescendants(
+            dependencyValues,
+            "creditAchievedForProgress"
+          )
         }
       };
-      if (stateValues.aggregateScores) {
-        dependencies2.scoredDescendants = {
-          dependencyType: "stateVariable",
-          variableName: "scoredDescendants"
-        };
-        for (let [
-          ind,
-          descendant
-        ] of stateValues.scoredDescendants.entries()) {
-          dependencies2["creditAchievedIfSubmit" + ind] = {
-            dependencyType: "stateVariable",
-            componentIdx: descendant.componentIdx,
-            variableName: "creditAchievedIfSubmit"
-          };
-        }
-      }
-      return dependencies2;
-    },
+    }
+  };
+  stateVariableDefinitions.creditAchievedIfSubmit = {
+    defaultValue: 0,
+    stateVariablesDeterminingDependencies: [
+      "aggregateScores",
+      "scoredDescendants"
+    ],
+    returnDependencies: returnAggregateCreditDependencies(
+      "creditAchievedIfSubmit"
+    ),
     definition({ dependencyValues }) {
       if (!dependencyValues.aggregateScores) {
         return {
@@ -83884,18 +83991,21 @@ function returnScoredSectionStateVariableDefinition() {
           }
         };
       }
-      let creditSum = 0;
-      let totalWeight = 0;
-      for (let [
-        ind,
-        component
-      ] of dependencyValues.scoredDescendants.entries()) {
-        let weight = component.stateValues.weight;
-        creditSum += dependencyValues["creditAchievedIfSubmit" + ind] * weight;
-        totalWeight += weight;
-      }
-      let creditAchievedIfSubmit = creditSum / totalWeight;
-      return { setValue: { creditAchievedIfSubmit } };
+      return {
+        setValue: {
+          creditAchievedIfSubmit: aggregateCreditOverScoredDescendants(
+            dependencyValues,
+            "creditAchievedIfSubmit",
+            // A section with nothing scored has always left
+            // this at NaN — the `0 / 0` of the average it used
+            // to take inline — where `creditAchieved` gives
+            // full credit. Passed explicitly so extracting the
+            // shared helper preserves the behavior rather than
+            // quietly changing it.
+            NaN
+          )
+        }
+      };
     }
   };
   stateVariableDefinitions.createSubmitAllButton = {
@@ -84729,28 +84839,6 @@ const Aliases = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   YLabel,
   cascadeMessage
 }, Symbol.toStringTag, { value: "Module" }));
-const BLANK_PLACEHOLDER = "＿";
-function latexWithBlanksAsPlaceholders(latex) {
-  return latex.split(MATH_BLANK_LATEX).join(BLANK_PLACEHOLDER);
-}
-function convertLatexWithBlanks(latex, convert) {
-  return convert(latexWithBlanksAsPlaceholders(latex));
-}
-function embeddedChildContent(child) {
-  const sv = child?.stateValues ?? {};
-  if (typeof sv.latex === "string") {
-    return sv.latex.trim();
-  }
-  if (typeof sv.text === "string") {
-    return sv.text.trim();
-  }
-  if (Array.isArray(sv.selectedValues)) {
-    return sv.selectedValues.map(
-      (value) => typeof value?.toLatex === "function" ? value.toLatex() : String(value ?? "")
-    ).filter((value) => value.trim() !== "").join(", ");
-  }
-  return "";
-}
 let M$3 = class M extends InlineComponent {
   constructor(args) {
     super(args);
@@ -98940,6 +99028,16 @@ class SectioningComponent extends BlockComponent {
       defaultValue: "var(--lightGreen)",
       description: "Color used to indicate this section has been completed."
     };
+    attributes.completedColorRequiresCredit = {
+      createComponentOfType: "boolean",
+      createStateVariable: "completedColorRequiresCreditPreliminary",
+      // See the note on `showCorrectness` in
+      // `returnScoredSectionAttributes`: this default is shown to authors
+      // but is not what resolves the value, which falls back to the
+      // enclosing section before reaching it.
+      defaultValue: false,
+      description: "Whether the completed color requires full `creditAchieved`, so that a section holding a hand-graded answer is not colored as completed until an instructor grades it. By default a hand-graded answer counts as completed once a non-blank response has been submitted. Affects only the color, not when a `<cascade>` advances."
+    };
     attributes.inProgressColor = {
       createComponentOfType: "text",
       createStateVariable: "inProgressColor",
@@ -99570,6 +99668,30 @@ class SectioningComponent extends BlockComponent {
         return { setValue: { title, titlePrefix } };
       }
     };
+    stateVariableDefinitions.completedColorRequiresCredit = {
+      description: "Whether the heading bar's completion state is driven by the real `creditAchieved` rather than by progress, so that a hand-graded answer keeps the section from being colored as completed until an instructor grades it.",
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "boolean"
+      },
+      returnDependencies: () => ({
+        completedColorRequiresCreditPreliminary: {
+          dependencyType: "stateVariable",
+          variableName: "completedColorRequiresCreditPreliminary"
+        },
+        completedColorRequiresCreditAncestor: {
+          dependencyType: "ancestor",
+          variableNames: ["completedColorRequiresCredit"]
+        }
+      }),
+      definition({ dependencyValues, usedDefault }) {
+        let completedColorRequiresCredit = dependencyValues.completedColorRequiresCreditPreliminary;
+        if (usedDefault.completedColorRequiresCreditPreliminary && dependencyValues.completedColorRequiresCreditAncestor) {
+          completedColorRequiresCredit = dependencyValues.completedColorRequiresCreditAncestor.stateValues.completedColorRequiresCredit;
+        }
+        return { setValue: { completedColorRequiresCredit } };
+      }
+    };
     stateVariableDefinitions.sectionTitleStateColors = {
       additionalStateVariablesDefined: [
         "sectionTitleStateColorsDarkMode",
@@ -99714,6 +99836,14 @@ class SectioningComponent extends BlockComponent {
           dependencyType: "stateVariable",
           variableName: "creditAchieved"
         },
+        creditAchievedForProgress: {
+          dependencyType: "stateVariable",
+          variableName: "creditAchievedForProgress"
+        },
+        completedColorRequiresCredit: {
+          dependencyType: "stateVariable",
+          variableName: "completedColorRequiresCredit"
+        },
         boxed: {
           dependencyType: "stateVariable",
           variableName: "boxed"
@@ -99725,7 +99855,7 @@ class SectioningComponent extends BlockComponent {
       }),
       definition({ dependencyValues }) {
         const titleStateKey = titleStateKeyFromCredit(
-          dependencyValues.creditAchieved
+          dependencyValues.completedColorRequiresCredit ? dependencyValues.creditAchieved : dependencyValues.creditAchievedForProgress
         );
         const titleColor = dependencyValues.sectionTitleStateColors[titleStateKey];
         const titleColorDarkMode = dependencyValues.sectionTitleStateColorsDarkMode[titleStateKey];
@@ -125723,6 +125853,7 @@ class Document extends BaseComponent {
       returnScoredSectionStateVariableDefinition()
     );
     delete stateVariableDefinitions.aggregateScores;
+    delete stateVariableDefinitions.creditAchievedForProgress;
     Object.assign(
       stateVariableDefinitions,
       returnSubmitLabelStateVariableDefinitions({
@@ -232285,13 +232416,13 @@ class Cascade extends SectioningComponent {
         children: {
           dependencyType: "child",
           childGroups: ["anything"],
-          variableNames: ["creditAchieved"],
+          variableNames: ["creditAchievedForProgress"],
           variablesOptional: true
         }
       }),
       definition({ dependencyValues }) {
         const childCreditAchieved = dependencyValues.children.map(
-          (child) => child.stateValues?.creditAchieved ?? null
+          (child) => child.stateValues?.creditAchievedForProgress ?? null
         );
         return { setValue: { childCreditAchieved } };
       }
@@ -239338,4 +239469,4 @@ export {
   getDefaultExportFromCjs$1 as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-6Spw9Yfi.js.map
+//# sourceMappingURL=index-Bin7pIAp.js.map