@doenet/v06-to-v07 0.7.0-beta11 → 0.7.0-beta12

package/core-info/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/core-info/core.ts"],"names":[],"mappings":"AAAA,OAAa,EACT,kBAAkB,IAAI,sBAAsB,EAO/C,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAyB,QAAQ,EAAS,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAmCxE,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACtC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CACzC,CAAC,sBAAsB,CAAC,CAAC;AAE1B,wBAAsB,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE;;;iCA8E9B,MAAM;GAS7C"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/core-info/core.ts"],"names":[],"mappings":"AAAA,OAAa,EACT,kBAAkB,IAAI,sBAAsB,EAO/C,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAyB,QAAQ,EAAS,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAqCxE,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACtC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CACzC,CAAC,sBAAsB,CAAC,CAAC;AAE1B,wBAAsB,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE;;;iCA8E9B,MAAM;GAS7C"}

package/index.js

@@ -10442,7 +10442,8 @@ function pretzelSugar(node) {
       name: "_pretzelArranger",
       children: node.children,
       attributes: {},
-      source_doc: node.source_doc
+      source_doc: node.source_doc,
+      position: node.position
     }
   ];
 }
@@ -61901,15 +61902,25 @@ class BaseComponent {
         adapterSourceHidden: {
           dependencyType: "adapterSourceStateVariable",
           variableName: "hidden"
+        },
+        parentChildrenToHide: {
+          dependencyType: "parentStateVariable",
+          variableName: "childrenToHide"
         }
       }),
-      definition: ({ dependencyValues }) => ({
-        setValue: {
-          hidden: Boolean(
-            dependencyValues.parentHidden || dependencyValues.sourceCompositeHidden || dependencyValues.adapterSourceHidden || dependencyValues.hide
-          )
-        }
-      }),
+      definition: ({ dependencyValues, componentIdx }) => {
+        return {
+          setValue: {
+            hidden: Boolean(
+              dependencyValues.parentHidden || dependencyValues.sourceCompositeHidden || dependencyValues.adapterSourceHidden || dependencyValues.hide || Array.isArray(
+                dependencyValues.parentChildrenToHide
+              ) && dependencyValues.parentChildrenToHide.includes(
+                componentIdx
+              )
+            )
+          }
+        };
+      },
       markStale: () => ({ updateParentRenderedChildren: true }),
       inverseDefinition({ desiredStateVariableValues }) {
         return {
@@ -67637,12 +67648,16 @@ function returnScoredSectionStateVariableDefinition() {
       sectionWideCheckWork: {
         dependencyType: "stateVariable",
         variableName: "sectionWideCheckWork"
+      },
+      parentChildrenAggregateScores: {
+        dependencyType: "parentStateVariable",
+        variableName: "childrenAggregateScores"
       }
     }),
     definition({ dependencyValues }) {
       return {
         setValue: {
-          aggregateScores: dependencyValues.aggregateScoresPreliminary || dependencyValues.sectionWideCheckWork
+          aggregateScores: dependencyValues.aggregateScoresPreliminary || dependencyValues.sectionWideCheckWork || dependencyValues.parentChildrenAggregateScores
         }
       };
     }
@@ -81078,6 +81093,12 @@ class SectioningComponent extends BlockComponent {
       defaultValue: false,
       public: true
     };
+    attributes.noAutoTitle = {
+      createComponentOfType: "boolean",
+      createStateVariable: "noAutoTitle",
+      defaultValue: false,
+      public: true
+    };
     attributes.includeAutoNameIfNoTitle = {
       createComponentOfType: "boolean",
       createStateVariable: "includeAutoNameIfNoTitle",
@@ -81101,6 +81122,16 @@ class SectioningComponent extends BlockComponent {
     attributes.renameTo = {
       createComponentOfType: "text"
     };
+    attributes.completedColor = {
+      createComponentOfType: "text",
+      createStateVariable: "completedColor",
+      defaultValue: "var(--lightGreen)"
+    };
+    attributes.inProgressColor = {
+      createComponentOfType: "text",
+      createStateVariable: "inProgressColor",
+      defaultValue: "var(--mainGray)"
+    };
     return attributes;
   }
   static returnChildGroups() {
@@ -81287,6 +81318,22 @@ class SectioningComponent extends BlockComponent {
         };
       }
     };
+    stateVariableDefinitions.hideChildren = {
+      returnDependencies: () => ({
+        parentChildrenToHideChildren: {
+          dependencyType: "parentStateVariable",
+          variableName: "childrenToHideChildren"
+        }
+      }),
+      definition({ dependencyValues, componentIdx }) {
+        let hideChildren = Boolean(
+          dependencyValues.parentChildrenToHideChildren?.includes(
+            componentIdx
+          )
+        );
+        return { setValue: { hideChildren } };
+      }
+    };
     stateVariableDefinitions.childIndicesToRender = {
       returnDependencies: () => ({
         titleChildren: {
@@ -81312,7 +81359,7 @@ class SectioningComponent extends BlockComponent {
         }
       }),
       definition({ dependencyValues, componentInfoObjects: componentInfoObjects2 }) {
-        let childIndicesToRender = [];
+        const childIndicesToRender = [];
         let allTitleChildNames = dependencyValues.titleChildren.map(
           (x2) => x2.componentIdx
         );
@@ -81334,7 +81381,39 @@ class SectioningComponent extends BlockComponent {
           }
         }
         return { setValue: { childIndicesToRender } };
-      }
+      },
+      markStale: () => ({ updateRenderedChildren: true })
+    };
+    stateVariableDefinitions.childrenToHide = {
+      returnDependencies: () => ({
+        allChildren: {
+          dependencyType: "child",
+          childGroups: [
+            "anything",
+            "variantControls",
+            "titles",
+            "setups"
+          ]
+        },
+        titleChildName: {
+          dependencyType: "stateVariable",
+          variableName: "titleChildName"
+        },
+        hideChildren: {
+          dependencyType: "stateVariable",
+          variableName: "hideChildren"
+        }
+      }),
+      definition({ dependencyValues }) {
+        const childrenToHide = [];
+        for (let child of dependencyValues.allChildren) {
+          if (dependencyValues.hideChildren && child.componentIdx !== dependencyValues.titleChildName) {
+            childrenToHide.push(child.componentIdx);
+          }
+        }
+        return { setValue: { childrenToHide } };
+      },
+      markStale: () => ({ updateRenderedChildren: true })
     };
     stateVariableDefinitions.startsWithIntroduction = {
       additionalStateVariablesDefined: [
@@ -81418,14 +81497,18 @@ class SectioningComponent extends BlockComponent {
         includeAutoNumberIfNoTitle: {
           dependencyType: "stateVariable",
           variableName: "includeAutoNumberIfNoTitle"
+        },
+        noAutoTitle: {
+          dependencyType: "stateVariable",
+          variableName: "noAutoTitle"
         }
       }),
       definition({ dependencyValues }) {
         let titlePrefix = "";
         let title2 = "";
         const haveTitleChild = dependencyValues.titleChild.length > 0;
-        let includeAutoNumber = (dependencyValues.includeAutoNumber || !haveTitleChild && dependencyValues.includeAutoNumberIfNoTitle) && !dependencyValues.prerender;
-        let includeAutoName = dependencyValues.includeAutoName || !haveTitleChild && dependencyValues.includeAutoNameIfNoTitle;
+        let includeAutoNumber = (dependencyValues.includeAutoNumber || !haveTitleChild && dependencyValues.includeAutoNumberIfNoTitle && !dependencyValues.noAutoTitle) && !dependencyValues.prerender;
+        let includeAutoName = dependencyValues.includeAutoName || !haveTitleChild && dependencyValues.includeAutoNameIfNoTitle && !dependencyValues.noAutoTitle;
         if (includeAutoNumber) {
           if (includeAutoName) {
             titlePrefix = dependencyValues.sectionName + " ";
@@ -81451,6 +81534,53 @@ class SectioningComponent extends BlockComponent {
         return { setValue: { title: title2, titlePrefix } };
       }
     };
+    stateVariableDefinitions.titleColor = {
+      // Note: currently title color is used only when boxed or collapsible
+      forRenderer: true,
+      returnDependencies: () => ({
+        completedColor: {
+          dependencyType: "stateVariable",
+          variableName: "completedColor"
+        },
+        inProgressColor: {
+          dependencyType: "stateVariable",
+          variableName: "inProgressColor"
+        },
+        parentCompletedColor: {
+          dependencyType: "parentStateVariable",
+          variableName: "completedColor"
+        },
+        parentInProgressColor: {
+          dependencyType: "parentStateVariable",
+          variableName: "inProgressColor"
+        },
+        creditAchieved: {
+          dependencyType: "stateVariable",
+          variableName: "creditAchieved"
+        }
+      }),
+      definition({ dependencyValues, usedDefault }) {
+        let titleColor = dependencyValues.inProgressColor;
+        if (dependencyValues.creditAchieved === 1) {
+          if (!usedDefault.completedColor) {
+            titleColor = dependencyValues.completedColor;
+          } else if (typeof dependencyValues.parentCompletedColor === "string") {
+            titleColor = dependencyValues.parentCompletedColor;
+          } else {
+            titleColor = dependencyValues.completedColor;
+          }
+        } else {
+          if (!usedDefault.inProgressColor) {
+            titleColor = dependencyValues.inProgressColor;
+          } else if (typeof dependencyValues.parentInProgressColor === "string") {
+            titleColor = dependencyValues.parentInProgressColor;
+          } else {
+            titleColor = dependencyValues.inProgressColor;
+          }
+        }
+        return { setValue: { titleColor } };
+      }
+    };
     stateVariableDefinitions.containerTag = {
       forRenderer: true,
       returnDependencies: () => ({}),
@@ -179176,6 +179306,12 @@ class SelectFromSequence extends Sequence {
     attributes.excludeCombinations = {
       createComponentOfType: "_componentListOfListsWithSelectableType"
     };
+    attributes.coprimeCombinations = {
+      createComponentOfType: "boolean",
+      createStateVariable: "coprimeCombinations",
+      defaultValue: false,
+      public: true
+    };
     return attributes;
   }
   static returnStateVariableDefinitions() {
@@ -179194,9 +179330,20 @@ class SelectFromSequence extends Sequence {
         numToSelect: {
           dependencyType: "stateVariable",
           variableName: "numToSelect"
+        },
+        coprimeCombinations: {
+          dependencyType: "stateVariable",
+          variableName: "coprimeCombinations"
         }
       }),
       definition: function({ dependencyValues }) {
+        const warnings = [];
+        if (dependencyValues.coprimeCombinations && dependencyValues.type !== "number") {
+          warnings.push({
+            message: "coprimeCombinations ignored since not selecting numbers",
+            level: 1
+          });
+        }
         if (dependencyValues.excludeCombinations !== null) {
           let excludedCombinations = dependencyValues.excludeCombinations.stateValues.lists.map(
             (x2) => x2.slice(0, dependencyValues.numToSelect)
@@ -179214,12 +179361,24 @@ class SelectFromSequence extends Sequence {
                 break;
               }
             }
+            if (dependencyValues.coprimeCombinations) {
+              warnings.push({
+                message: "coprimeCombinations ignored since excludeCombinations specified",
+                level: 1
+              });
+            }
           }
           return {
-            setValue: { excludedCombinations }
+            setValue: { excludedCombinations },
+            sendWarnings: warnings
           };
         } else {
-          return { setValue: { excludedCombinations: [] } };
+          return {
+            setValue: {
+              excludedCombinations: []
+            },
+            sendWarnings: warnings
+          };
         }
       }
     };
@@ -179280,6 +179439,10 @@ class SelectFromSequence extends Sequence {
           dependencyType: "stateVariable",
           variableName: "excludedCombinations"
         },
+        coprimeCombinations: {
+          dependencyType: "stateVariable",
+          variableName: "coprimeCombinations"
+        },
         type: {
           dependencyType: "stateVariable",
           variableName: "type"
@@ -179426,6 +179589,15 @@ class SelectFromSequence extends Sequence {
         return { success: false };
       }
     }
+    let coprimeCombinationsComponent = serializedComponent.attributes.coprimeCombinations?.component;
+    if (coprimeCombinationsComponent) {
+      if (!(coprimeCombinationsComponent.componentType === "boolean" && coprimeCombinationsComponent.children?.length === 1 && typeof coprimeCombinationsComponent.children[0] === "string" && coprimeCombinationsComponent.children[0].trim().toLowerCase() === "false")) {
+        console.log(
+          `cannot determine unique variants of selectFromSequence as cannot determine coprimeCombinations is always false.`
+        );
+        return { success: false };
+      }
+    }
     let withReplacementComponent = serializedComponent.attributes.withReplacement?.component;
     if (withReplacementComponent) {
       if (withReplacementComponent.componentType === "boolean") {
@@ -179878,16 +180050,57 @@ function makeSelection$1({ dependencyValues }) {
     }
   }
   let numCombinationsExcluded = dependencyValues.excludedCombinations.length;
+  let coprimeCombinations = dependencyValues.coprimeCombinations;
   if (dependencyValues.type === "number") {
+    let errorMessage = null;
     numCombinationsExcluded = estimateNumberOfNumberCombinationsExcluded({
       excludedCombinations: dependencyValues.excludedCombinations,
       numValues: dependencyValues.length - dependencyValues.exclude.length,
       withReplacement: dependencyValues.withReplacement,
       numToSelect: dependencyValues.numToSelect
     });
+    if (coprimeCombinations) {
+      const lastNumber = dependencyValues.from + (dependencyValues.length - 1) * dependencyValues.step;
+      if (numCombinationsExcluded > 0) {
+        coprimeCombinations = false;
+      } else if (!Number.isInteger(dependencyValues.from) || !Number.isInteger(dependencyValues.step) || dependencyValues.from <= 0 || lastNumber <= 0) {
+        errorMessage = "Cannot select coprime combinations as not selecting positive integers.";
+      } else if (Context.math.gcd(dependencyValues.from, dependencyValues.step) !== 1) {
+        errorMessage = `Cannot select coprime numbers. All possible values share a common factor. (Specified values of "from" or "to" must be coprime with "step".)`;
+      } else if (dependencyValues.numToSelect === 1) {
+        coprimeCombinations = false;
+      } else if (dependencyValues.length - dependencyValues.exclude.length <= 1) {
+        if (dependencyValues.from > 1 || dependencyValues.exclude.includes(1)) {
+          if (dependencyValues.length <= 1) {
+            errorMessage = "Cannot select coprime combinations from a single number that is not 1.";
+          } else {
+            const possibleValues = returnSequenceValues(dependencyValues);
+            if (possibleValues.length <= 1) {
+              errorMessage = "Cannot select coprime combinations from a single number that is not 1.";
+            }
+          }
+        }
+      }
+    }
+    if (errorMessage) {
+      return {
+        setEssentialValue: {
+          errorMessage,
+          selectedValues: null,
+          selectedIndices: null
+        },
+        setValue: {
+          errorMessage,
+          selectedValues: null,
+          selectedIndices: null
+        }
+      };
+    }
+  } else {
+    coprimeCombinations = false;
   }
   let selectedValues, selectedIndices;
-  if (numCombinationsExcluded === 0) {
+  if (numCombinationsExcluded === 0 && !coprimeCombinations) {
     let selectedObj = selectValuesAndIndices({
       stateValues: dependencyValues,
       numUniqueRequired,
@@ -180023,11 +180236,19 @@ function makeSelection$1({ dependencyValues }) {
       })) {
         continue;
       }
+      if (coprimeCombinations && Context.math.gcd(...selectedValues) !== 1) {
+        continue;
+      }
       foundValidCombination = true;
       break;
     }
     if (!foundValidCombination) {
-      let errorMessage = "By extremely unlikely fluke, couldn't select combination of random values";
+      let errorMessage;
+      if (coprimeCombinations) {
+        errorMessage = "Could not select coprime numbers. All possible values share a common factor.";
+      } else {
+        errorMessage = "By extremely unlikely fluke, couldn't select combination of random values";
+      }
       return {
         setEssentialValue: {
           errorMessage,
@@ -201226,10 +201447,6 @@ class PretzelArranger extends CompositeComponent {
     stateVariableDefinitions.statements = {
       additionalStateVariablesDefined: ["givenAnswers", "validProblems"],
       returnDependencies: () => ({
-        numProblems: {
-          dependencyType: "stateVariable",
-          variableName: "numProblems"
-        },
         serializedProblemChildren: {
           dependencyType: "stateVariable",
           variableName: "serializedProblemChildren"
@@ -201306,7 +201523,19 @@ class PretzelArranger extends CompositeComponent {
       const problemIdx = problemOrder[i2] - 1;
       const thisStatement = statements[problemIdx];
       const prevAnswer = givenAnswers[(problemIdx - 1 + numProblems) % numProblems];
-      replacements.push(prevAnswer);
+      if (prevAnswer === null) {
+        replacements.push({
+          type: "serialized",
+          componentType: "span",
+          componentIdx: nComponents++,
+          attributes: {},
+          doenetAttributes: {},
+          state: {},
+          children: []
+        });
+      } else {
+        replacements.push(prevAnswer);
+      }
       replacements.push({
         type: "serialized",
         componentType: "textInput",
@@ -201332,7 +201561,19 @@ class PretzelArranger extends CompositeComponent {
         state: {},
         children: []
       });
-      replacements.push(thisStatement);
+      if (thisStatement === null) {
+        replacements.push({
+          type: "serialized",
+          componentType: "statement",
+          componentIdx: nComponents++,
+          attributes: {},
+          doenetAttributes: {},
+          state: {},
+          children: []
+        });
+      } else {
+        replacements.push(thisStatement);
+      }
     }
     return {
       replacements,
@@ -201456,6 +201697,158 @@ class PretzelArranger extends CompositeComponent {
     return { success: true, desiredVariant };
   }
 }
+class Cascade extends SectioningComponent {
+  static componentType = "cascade";
+  static rendererType = "section";
+  static includeBlankStringChildren = false;
+  static createAttributesObject() {
+    let attributes = super.createAttributesObject();
+    attributes.hideFutureSections = {
+      createComponentOfType: "boolean",
+      createStateVariable: "hideFutureSections",
+      defaultValue: false,
+      public: true
+    };
+    attributes.noAutoTitle.defaultValue = true;
+    attributes.revealAll = {
+      createComponentOfType: "boolean",
+      createStateVariable: "revealAllPreliminary",
+      defaultValue: false
+    };
+    return attributes;
+  }
+  static returnStateVariableDefinitions() {
+    let stateVariableDefinitions = super.returnStateVariableDefinitions();
+    stateVariableDefinitions.childrenAggregateScores = {
+      returnDependencies: () => ({}),
+      definition: () => ({ setValue: { childrenAggregateScores: true } })
+    };
+    stateVariableDefinitions.childCreditAchieved = {
+      returnDependencies: () => ({
+        children: {
+          dependencyType: "child",
+          childGroups: ["anything"],
+          variableNames: ["creditAchieved"],
+          variablesOptional: true
+        }
+      }),
+      definition({ dependencyValues }) {
+        const childCreditAchieved = dependencyValues.children.map(
+          (child) => child.stateValues?.creditAchieved ?? null
+        );
+        return { setValue: { childCreditAchieved } };
+      }
+    };
+    stateVariableDefinitions.numCompleted = {
+      public: true,
+      shadowingInstructions: {
+        createComponentOfType: "integer"
+      },
+      returnDependencies: () => ({
+        childCreditAchieved: {
+          dependencyType: "stateVariable",
+          variableName: "childCreditAchieved"
+        }
+      }),
+      definition({ dependencyValues }) {
+        let numCompleted = 0;
+        for (const childCredit of dependencyValues.childCreditAchieved) {
+          if (childCredit === 1 || childCredit === null) {
+            numCompleted++;
+          } else {
+            break;
+          }
+        }
+        return { setValue: { numCompleted } };
+      }
+    };
+    stateVariableDefinitions.revealAll = {
+      returnDependencies: () => ({
+        cascadeAncestor: {
+          dependencyType: "ancestor",
+          componentType: "cascade",
+          variableNames: ["revealAll"]
+        },
+        revealAllPreliminary: {
+          dependencyType: "stateVariable",
+          variableName: "revealAllPreliminary"
+        }
+      }),
+      definition({ dependencyValues, usedDefault }) {
+        let revealAll = false;
+        if (!usedDefault.revealAllPreliminary) {
+          revealAll = dependencyValues.revealAllPreliminary;
+        } else if (dependencyValues.cascadeAncestor) {
+          revealAll = dependencyValues.cascadeAncestor.stateValues.revealAll;
+        } else {
+          dependencyValues.revealAllPreliminary;
+        }
+        return { setValue: { revealAll } };
+      }
+    };
+    stateVariableDefinitions.childrenToHide = {
+      additionalStateVariablesDefined: ["childrenToHideChildren"],
+      returnDependencies: () => ({
+        hideFutureSections: {
+          dependencyType: "stateVariable",
+          variableName: "hideFutureSections"
+        },
+        numCompleted: {
+          dependencyType: "stateVariable",
+          variableName: "numCompleted"
+        },
+        children: {
+          dependencyType: "child",
+          childGroups: ["anything"]
+        },
+        revealAll: {
+          dependencyType: "stateVariable",
+          variableName: "revealAll"
+        },
+        hideChildren: {
+          dependencyType: "stateVariable",
+          variableName: "hideChildren"
+        }
+      }),
+      definition({ dependencyValues, componentInfoObjects: componentInfoObjects2 }) {
+        if (dependencyValues.revealAll) {
+          return {
+            setValue: {
+              childrenToHide: [],
+              childrenToHideChildren: []
+            }
+          };
+        }
+        const childrenToHide = [];
+        const childrenToHideChildren = [];
+        for (const [
+          idx,
+          child
+        ] of dependencyValues.children.entries()) {
+          if (idx <= dependencyValues.numCompleted) {
+            if (dependencyValues.hideChildren) {
+              childrenToHide.push(child.componentIdx);
+            }
+          } else if (!dependencyValues.hideChildren && !dependencyValues.hideFutureSections && componentInfoObjects2.isInheritedComponentType({
+            inheritedComponentType: child.componentType,
+            baseComponentType: "_sectioningComponent"
+          })) {
+            childrenToHideChildren.push(child.componentIdx);
+          } else {
+            childrenToHide.push(child.componentIdx);
+          }
+        }
+        return {
+          setValue: {
+            childrenToHide,
+            childrenToHideChildren
+          }
+        };
+      }
+    };
+    return stateVariableDefinitions;
+  }
+}
 const unitConversions = {
   "": 1,
   px: 1,
@@ -205399,6 +205792,7 @@ const componentTypeArray = [
   StickyGroup,
   Pretzel,
   PretzelArranger,
+  Cascade,
   BaseComponent,
   InlineComponent,
   BlockComponent,
@@ -207045,6 +207439,7 @@ const defaultFlags = {
   allowSaveState: true,
   allowLocalState: false,
   allowSaveEvents: true,
+  messageParent: false,
   autoSubmit: false
 };
 async function createCoreForLookup({ dast }) {