@doenet/v06-to-v07 0.7.20-dev.307 → 0.7.20-dev.308

package/{index-C0ofSjwe.js → index-BmXW0q7U.js}

@@ -10899,6 +10899,50 @@ function answerSugar(node) {
     node.children = [answerElement, videoCreditMessage, callActionElement];
   }
 }
+const SCORED_SECTION_COMPONENT_TYPES = [
+  "document",
+  "section",
+  "subsection",
+  "subsubsection",
+  "paragraphs",
+  "aside",
+  "objectives",
+  "problem",
+  "exercise",
+  "question",
+  "activity",
+  "example",
+  "definition",
+  "note",
+  "theorem",
+  "part",
+  "task",
+  "proof",
+  "problems",
+  "exercises",
+  "standinForFutureLayoutTag",
+  "externalContent",
+  "cascade",
+  "div",
+  "span",
+  "ol",
+  "ul",
+  "li",
+  "p"
+];
+function renamedScoredSectionAttribute(oldName, newName) {
+  const rule = {
+    to: newName,
+    warningMessage: `[deprecation] Attribute \`${oldName}\` is deprecated; use \`${newName}\` instead.`,
+    conflictWarningMessage: `[deprecation] Attribute \`${oldName}\` is deprecated and ignored because \`${newName}\` is also specified.`
+  };
+  return Object.fromEntries(
+    SCORED_SECTION_COMPONENT_TYPES.map((comp) => [
+      comp,
+      { [oldName]: rule }
+    ])
+  );
+}
 function ignoredAttributes(componentName, attributeNames) {
   return Object.fromEntries(
     attributeNames.map((attributeName) => [
@@ -10909,9 +10953,19 @@ function ignoredAttributes(componentName, attributeNames) {
     ])
   );
 }
+const SCORED_SECTION_COLORING_RENAMES = renamedScoredSectionAttribute(
+  "forceIndividualAnswerColoring",
+  "colorAnswersSeparately"
+);
 const DEPRECATION_REGISTRY = {
   attributeRenames: {
+    // Merge per-component rules, spreading scored-section rename rules
+    // first so component-specific rules take precedence on conflict.
+    ...SCORED_SECTION_COLORING_RENAMES,
     document: {
+      // document already has a scored-section rename (spread above) plus
+      // its own documentWideCheckWork rename.
+      ...SCORED_SECTION_COLORING_RENAMES["document"],
       documentWideCheckWork: {
         to: "sectionWideCheckWork",
         warningMessage: "[deprecation] Attribute `documentWideCheckWork` on `<document>` is deprecated; use `sectionWideCheckWork` instead.",
@@ -40909,7 +40963,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-C0vj3HDn-ILc8kzpi-tZRzzwtP.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-Cy4MoSBb-D7vYyaIg.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -57252,6 +57306,30 @@ const _UnlinkedCopySourceDependency = class _UnlinkedCopySourceDependency2 exten
 };
 _UnlinkedCopySourceDependency.dependencyType = "unlinkedCopySource";
 let UnlinkedCopySourceDependency = _UnlinkedCopySourceDependency;
+const _ShadowInfoDependency = class _ShadowInfoDependency2 extends Dependency {
+  setUpParameters() {
+    if (this.definition.componentIdx != void 0) {
+      this.componentIdx = this.definition.componentIdx;
+    } else {
+      this.componentIdx = this.upstreamComponentIdx;
+    }
+  }
+  async getValue() {
+    const component = this.dependencyHandler._components[this.componentIdx];
+    if (!component?.shadows) {
+      return { value: null, changes: {} };
+    }
+    return {
+      value: {
+        componentIdx: component.shadows.componentIdx,
+        propVariable: component.shadows.propVariable ?? null
+      },
+      changes: {}
+    };
+  }
+};
+_ShadowInfoDependency.dependencyType = "shadowInfo";
+let ShadowInfoDependency = _ShadowInfoDependency;
 const _PrimaryShadowDependency = class _PrimaryShadowDependency2 extends Dependency {
   setUpParameters() {
     if (this.definition.componentIdx != void 0) {
@@ -58400,6 +58478,7 @@ const dependencyTypeClasses = [
   ShadowSourceDependency,
   UnlinkedCopySourceDependency,
   PrimaryShadowDependency,
+  ShadowInfoDependency,
   AdapterSourceStateVariableDependency,
   AdapterSourceDependency,
   CountAmongSiblingsDependency,
@@ -74964,12 +75043,12 @@ function returnScoredSectionAttributes() {
       groupName: "scoring",
       description: "Whether to color-code the answers it contains based on correctness."
     },
-    forceIndividualAnswerColoring: {
+    colorAnswersSeparately: {
       createComponentOfType: "boolean",
-      createStateVariable: "forceIndividualAnswerColoring",
+      createStateVariable: "colorAnswersSeparately",
       defaultValue: false,
       groupName: "scoring",
-      description: "Whether to force per-answer color-correctness even when section-wide check work is enabled."
+      description: "When section-wide check work is enabled, color each answer based on its own correctness rather than the section's overall credit."
     },
     submitLabel: {
       createComponentOfType: "text",
@@ -75415,9 +75494,9 @@ function returnScoredSectionStateVariableDefinition() {
         dependencyType: "stateVariable",
         variableName: "sectionWideCheckWork"
       },
-      forceIndividualAnswerColoring: {
+      colorAnswersSeparately: {
         dependencyType: "stateVariable",
-        variableName: "forceIndividualAnswerColoring"
+        variableName: "colorAnswersSeparately"
       },
       ancestorDeterminingSubmit: {
         dependencyType: "ancestor",
@@ -75437,7 +75516,7 @@ function returnScoredSectionStateVariableDefinition() {
       } else if (dependencyValues.sectionWideCheckWork) {
         createSubmitAllButton = true;
         suppressAnswerSubmitButtons = true;
-        if (!dependencyValues.forceIndividualAnswerColoring) {
+        if (!dependencyValues.colorAnswersSeparately) {
           descendantColorCorrectnessBasedOnIdx = componentIdx;
         }
       }
@@ -111064,7 +111143,8 @@ class Input extends InlineComponent {
             "nextCreditFactor",
             "forceFullCheckWorkButton",
             "forceSmallCheckWorkButton",
-            "labelsForAnswer"
+            "labelsForAnswer",
+            "colorInputsSeparately"
           ]
         }
       }),
@@ -111151,7 +111231,8 @@ class Input extends InlineComponent {
               "justSubmitted",
               "creditAchieved",
               "showCorrectness",
-              "colorCorrectness"
+              "colorCorrectness",
+              "colorInputsSeparately"
             ],
             variablesOptional: true
           };
@@ -111236,18 +111317,63 @@ class Input extends InlineComponent {
         return { setValue: { colorCorrectness } };
       }
     };
+    const variableForImplicitProp = this.variableForImplicitProp ?? "value";
     stateVariableDefinitions.creditAchieved = {
       forRenderer: true,
-      returnDependencies: () => ({
-        componentDeterminingDisplayedCorrectness: {
-          dependencyType: "stateVariable",
-          variableName: "componentDeterminingDisplayedCorrectness"
+      stateVariablesDeterminingDependencies: [
+        "answerAncestor",
+        "answerSpecifiedInForAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          componentDeterminingDisplayedCorrectness: {
+            dependencyType: "stateVariable",
+            variableName: "componentDeterminingDisplayedCorrectness"
+          }
+        };
+        if (stateValues.answerAncestor?.stateValues.colorInputsSeparately) {
+          deps.answerCreditAchievedPerInput = {
+            dependencyType: "ancestor",
+            componentType: "answer",
+            variableNames: ["creditAchievedPerInput"]
+          };
+        } else if (stateValues.answerSpecifiedInForAnswer !== null) {
+          deps.answerColoringState = {
+            dependencyType: "multipleStateVariables",
+            componentIdx: stateValues.answerSpecifiedInForAnswer,
+            variableNames: [
+              "colorInputsSeparately",
+              "creditAchievedPerInput"
+            ],
+            variablesOptional: true
+          };
         }
-      }),
-      definition: function({ dependencyValues }) {
+        return deps;
+      },
+      definition: function({ dependencyValues, componentIdx }) {
         let creditAchieved = 0;
-        if (dependencyValues.componentDeterminingDisplayedCorrectness) {
-          creditAchieved = dependencyValues.componentDeterminingDisplayedCorrectness.stateValues.creditAchieved;
+        const comp = dependencyValues.componentDeterminingDisplayedCorrectness;
+        if (comp) {
+          const overallCredit = comp.stateValues.creditAchieved ?? 0;
+          const creditAchievedPerInput = dependencyValues.answerCreditAchievedPerInput?.stateValues.creditAchievedPerInput ?? (dependencyValues.answerColoringState?.stateValues?.colorInputsSeparately ? dependencyValues.answerColoringState.stateValues.creditAchievedPerInput : void 0);
+          if (comp.stateValues.colorInputsSeparately && creditAchievedPerInput) {
+            const key = `${componentIdx}/${variableForImplicitProp}`;
+            let perInputCredit = creditAchievedPerInput[key];
+            if (perInputCredit === void 0 && variableForImplicitProp !== "value") {
+              const keyPrefix = `${componentIdx}/`;
+              const candidateCredits = Object.entries(
+                creditAchievedPerInput
+              ).filter(
+                ([entryKey]) => entryKey.startsWith(keyPrefix)
+              ).map(([, credit]) => credit);
+              if (candidateCredits.length > 0) {
+                perInputCredit = Math.max(...candidateCredits);
+              }
+            }
+            creditAchieved = perInputCredit !== void 0 ? perInputCredit : overallCredit;
+          } else {
+            creditAchieved = overallCredit;
+          }
         }
         return {
           setValue: { creditAchieved }
@@ -115698,6 +115824,88 @@ class FractionInput extends Input {
         }
       })
     };
+    stateVariableDefinitions.componentIdx = {
+      returnDependencies: () => ({}),
+      definition({ componentIdx }) {
+        return { setValue: { componentIdx } };
+      }
+    };
+    stateVariableDefinitions.colorInputsSeparately = {
+      stateVariablesDeterminingDependencies: [
+        "answerSpecifiedInForAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          answerAncestor: {
+            dependencyType: "stateVariable",
+            variableName: "answerAncestor"
+          }
+        };
+        if (stateValues.answerSpecifiedInForAnswer !== null) {
+          deps.forAnswerColorInputsSeparately = {
+            dependencyType: "stateVariable",
+            componentIdx: stateValues.answerSpecifiedInForAnswer,
+            variableName: "colorInputsSeparately",
+            variablesOptional: true
+          };
+        }
+        return deps;
+      },
+      definition({ dependencyValues }) {
+        if (dependencyValues.answerAncestor) {
+          return {
+            setValue: {
+              colorInputsSeparately: dependencyValues.answerAncestor.stateValues.colorInputsSeparately ?? false
+            }
+          };
+        }
+        return {
+          setValue: {
+            colorInputsSeparately: dependencyValues.forAnswerColorInputsSeparately ?? false
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.creditAchievedPerInput = {
+      stateVariablesDeterminingDependencies: [
+        "colorInputsSeparately",
+        "answerAncestor",
+        "answerSpecifiedInForAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        if (!stateValues.colorInputsSeparately) {
+          return {};
+        }
+        if (stateValues.answerAncestor) {
+          return {
+            answerCreditAchievedPerInput: {
+              dependencyType: "ancestor",
+              componentType: "answer",
+              variableNames: ["creditAchievedPerInput"]
+            }
+          };
+        }
+        if (stateValues.answerSpecifiedInForAnswer !== null) {
+          return {
+            answerCreditAchievedPerInput: {
+              dependencyType: "stateVariable",
+              componentIdx: stateValues.answerSpecifiedInForAnswer,
+              variableName: "creditAchievedPerInput",
+              returnAsComponentObject: true,
+              variablesOptional: true
+            }
+          };
+        }
+        return {};
+      },
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            creditAchievedPerInput: dependencyValues.answerCreditAchievedPerInput?.stateValues?.creditAchievedPerInput ?? {}
+          }
+        };
+      }
+    };
     return stateVariableDefinitions;
   }
   static adapters = [
@@ -115834,18 +116042,49 @@ class FractionComponentInput extends BaseComponent {
     };
     stateVariableDefinitions.creditAchieved = {
       forRenderer: true,
-      returnDependencies: () => ({
-        parentCreditAchieved: {
+      stateVariablesDeterminingDependencies: ["part"],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          parentCreditAchieved: {
+            dependencyType: "parentStateVariable",
+            parentComponentType: "fractionInput",
+            variableName: "creditAchieved"
+          },
+          parentColorInputsSeparately: {
+            dependencyType: "parentStateVariable",
+            parentComponentType: "fractionInput",
+            variableName: "colorInputsSeparately"
+          }
+        };
+        deps.parentCreditAchievedPerInput = {
           dependencyType: "parentStateVariable",
           parentComponentType: "fractionInput",
-          variableName: "creditAchieved"
-        }
-      }),
+          variableName: "creditAchievedPerInput"
+        };
+        deps.parentComponentIdx = {
+          dependencyType: "parentStateVariable",
+          parentComponentType: "fractionInput",
+          variableName: "componentIdx"
+        };
+        deps.part = {
+          dependencyType: "stateVariable",
+          variableName: "part"
+        };
+        return deps;
+      },
       definition({ dependencyValues }) {
+        const fallback = dependencyValues.parentCreditAchieved ?? 0;
+        if (dependencyValues.parentColorInputsSeparately && dependencyValues.parentCreditAchievedPerInput && dependencyValues.parentComponentIdx !== void 0 && dependencyValues.part) {
+          const key = `${dependencyValues.parentComponentIdx}/${dependencyValues.part}`;
+          const perPartCredit = dependencyValues.parentCreditAchievedPerInput[key];
+          return {
+            setValue: {
+              creditAchieved: perPartCredit !== void 0 ? perPartCredit : fallback
+            }
+          };
+        }
         return {
-          setValue: {
-            creditAchieved: dependencyValues.parentCreditAchieved ?? 0
-          }
+          setValue: { creditAchieved: fallback }
         };
       }
     };
@@ -135761,6 +136000,13 @@ class Answer extends InlineComponent {
       public: true,
       description: "Maximum number of matching awards whose credits are summed."
     };
+    attributes.colorInputsSeparately = {
+      createComponentOfType: "boolean",
+      createStateVariable: "colorInputsSeparately",
+      defaultValue: false,
+      public: true,
+      description: "Attempt to color each input separately based on the awards that reference it, rather than all inputs sharing the same overall credit color."
+    };
     attributes.allowedErrorInNumbers = {
       createComponentOfType: "number",
       createStateVariable: "allowedErrorInNumbers",
@@ -136584,6 +136830,35 @@ class Answer extends InlineComponent {
         return { setValue: { inputChildWithValues } };
       }
     };
+    stateVariableDefinitions.allInputComponentIdxs = {
+      stateVariablesDeterminingDependencies: [
+        "inputChildRelativeIndices"
+      ],
+      returnDependencies: ({ stateValues }) => ({
+        inputChildren: {
+          dependencyType: "child",
+          childGroups: ["inputs"],
+          childIndices: stateValues.inputChildRelativeIndices
+        },
+        inputsForAnswer: {
+          dependencyType: "stateVariable",
+          variableName: "inputsForAnswer"
+        }
+      }),
+      definition({ dependencyValues }) {
+        const allInputComponentIdxs = /* @__PURE__ */ new Set([
+          ...dependencyValues.inputChildren.map(
+            (c2) => c2.componentIdx
+          ),
+          ...dependencyValues.inputsForAnswer.map(
+            (c2) => c2.componentIdx
+          )
+        ]);
+        return {
+          setValue: { allInputComponentIdxs }
+        };
+      }
+    };
     stateVariableDefinitions.inputComponentIdxForLabel = {
       stateVariablesDeterminingDependencies: ["inputChildrenWithValues"],
       additionalStateVariablesDefined: [
@@ -137414,6 +137689,50 @@ class Answer extends InlineComponent {
         };
       }
     };
+    stateVariableDefinitions.creditAchievedPerInput = {
+      returnDependencies: () => ({
+        awardChildren: {
+          dependencyType: "child",
+          childGroups: ["awards"],
+          variableNames: [
+            "awarded",
+            "creditAchieved",
+            "credit",
+            "referencedInputStateVars"
+          ]
+        }
+      }),
+      definition({ dependencyValues }) {
+        const maxCreditByKey = {};
+        const actualCreditByKey = {};
+        for (const award of dependencyValues.awardChildren) {
+          const referencedInputStateVars = award.stateValues.referencedInputStateVars;
+          const credit = award.stateValues.credit;
+          const awarded = award.stateValues.awarded;
+          const creditAchieved = award.stateValues.creditAchieved;
+          for (const {
+            componentIdx,
+            propVariable
+          } of referencedInputStateVars) {
+            const key = `${componentIdx}/${propVariable}`;
+            if (maxCreditByKey[key] === void 0 || credit > maxCreditByKey[key]) {
+              maxCreditByKey[key] = credit;
+            }
+            if (awarded && (actualCreditByKey[key] === void 0 || creditAchieved > actualCreditByKey[key])) {
+              actualCreditByKey[key] = creditAchieved;
+            }
+          }
+        }
+        const creditAchievedPerInput = {};
+        for (const key of Object.keys(maxCreditByKey)) {
+          const maxCredit = maxCreditByKey[key];
+          if (maxCredit > 0) {
+            creditAchievedPerInput[key] = (actualCreditByKey[key] ?? 0) / maxCredit;
+          }
+        }
+        return { setValue: { creditAchievedPerInput } };
+      }
+    };
     stateVariableDefinitions.numPreviousIncorrectSubmissions = {
       defaultValue: 0,
       hasEssential: true,
@@ -138490,6 +138809,60 @@ class Award extends BaseComponent {
       targetVariableName: "feedback1",
       description: "The first feedback message produced by this award."
     };
+    stateVariableDefinitions.colorInputsSeparatelyFromAnswer = {
+      returnDependencies: () => ({
+        colorInputsSeparately: {
+          dependencyType: "parentStateVariable",
+          variableName: "colorInputsSeparately"
+        }
+      }),
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            colorInputsSeparatelyFromAnswer: dependencyValues.colorInputsSeparately ?? false
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.referencedInputStateVars = {
+      stateVariablesDeterminingDependencies: [
+        "colorInputsSeparatelyFromAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          colorInputsSeparatelyFromAnswer: {
+            dependencyType: "parentStateVariable",
+            variableName: "colorInputsSeparately"
+          }
+        };
+        if (stateValues.colorInputsSeparatelyFromAnswer) {
+          deps.allInputComponentIdxs = {
+            dependencyType: "parentStateVariable",
+            variableName: "allInputComponentIdxs"
+          };
+          deps.whenChild = {
+            dependencyType: "child",
+            childGroups: ["whens"],
+            variableNames: ["referencedStateVars"]
+          };
+        }
+        return deps;
+      },
+      definition({ dependencyValues }) {
+        if (!dependencyValues.colorInputsSeparatelyFromAnswer) {
+          return { setValue: { referencedInputStateVars: [] } };
+        }
+        const allInputComponentIdxs = dependencyValues.allInputComponentIdxs ?? /* @__PURE__ */ new Set();
+        const referencedStateVars = dependencyValues.whenChild?.[0]?.stateValues.referencedStateVars ?? [];
+        return {
+          setValue: {
+            referencedInputStateVars: referencedStateVars.filter(
+              (ref) => allInputComponentIdxs.has(ref.componentIdx)
+            )
+          }
+        };
+      }
+    };
     return stateVariableDefinitions;
   }
   static standardizedFeedback = {
@@ -138721,6 +139094,43 @@ class When extends BooleanComponent {
         };
       }
     };
+    stateVariableDefinitions._descendantIdxs = {
+      returnDependencies: () => ({
+        allDescendants: {
+          dependencyType: "descendant",
+          componentTypes: ["_base"]
+        }
+      }),
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            _descendantIdxs: (dependencyValues.allDescendants ?? []).map((d2) => d2.componentIdx)
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.referencedStateVars = {
+      stateVariablesDeterminingDependencies: ["_descendantIdxs"],
+      returnDependencies({ stateValues }) {
+        const deps = {};
+        for (const idx of stateValues._descendantIdxs ?? []) {
+          deps[`shadowInfo_${idx}`] = {
+            dependencyType: "shadowInfo",
+            componentIdx: idx
+          };
+        }
+        return deps;
+      },
+      definition({ dependencyValues }) {
+        const referencedStateVars = [];
+        for (const [key, value] of Object.entries(dependencyValues)) {
+          if (key.startsWith("shadowInfo_") && value !== null) {
+            referencedStateVars.push(value);
+          }
+        }
+        return { setValue: { referencedStateVars } };
+      }
+    };
     return stateVariableDefinitions;
   }
   // "when" does not adapt to "text", even though boolean does
@@ -228313,4 +228723,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-C0ofSjwe.js.map
+//# sourceMappingURL=index-BmXW0q7U.js.map