@doenet/v06-to-v07 0.7.26-dev.581 → 0.7.26-dev.582

package/{index-DGyduyFg.js → index-DAy9ScBT.js}

@@ -47916,7 +47916,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-8sXzDnE0-CGiFZhfh-BBk7ox76.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-8sXzDnE0-CfHuPfKu-CMZLq65_.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -56639,21 +56639,25 @@ async function addReplacementsToResolver({
     updateOldReplacementsEnd,
     blankStringReplacements
   });
+  const fragmentParent = replacementActingAsFragmentParent(
+    serializedReplacements,
+    component
+  );
   const fragmentChildren = [];
   let parentSourceSequence = null;
-  if (component.attributes.createComponentIdx != null) {
-    if (serializedReplacements[0]?.children) {
-      fragmentChildren.push(...serializedReplacements[0].children);
+  if (fragmentParent) {
+    if (fragmentParent.children) {
+      fragmentChildren.push(...fragmentParent.children);
     }
-    for (const attrName in serializedReplacements[0]?.attributes) {
-      const attribute = serializedReplacements[0].attributes[attrName];
+    for (const attrName in fragmentParent.attributes) {
+      const attribute = fragmentParent.attributes[attrName];
       if (attribute.type === "component") {
         fragmentChildren.push(attribute.component);
       } else if (attribute.type === "references") {
         fragmentChildren.push(...attribute.references);
       }
     }
-    let sourceSequence = serializedReplacements[0]?.attributes["source:sequence"];
+    let sourceSequence = fragmentParent.attributes["source:sequence"];
     const createComponentIdxPrimitive = component.attributes.createComponentIdx?.primitive;
     if (sourceSequence && createComponentIdxPrimitive?.type === "number") {
       parentSourceSequence = {
@@ -56698,6 +56702,17 @@ async function addReplacementsToResolver({
     }
   }
 }
+function replacementActingAsFragmentParent(serializedReplacements, component) {
+  const createComponentIdx = component.attributes.createComponentIdx?.primitive?.value;
+  if (createComponentIdx == null || serializedReplacements.length !== 1) {
+    return null;
+  }
+  const replacement = serializedReplacements[0];
+  if (typeof replacement !== "object" || replacement === null || getEffectiveComponentIdx(replacement) !== createComponentIdx) {
+    return null;
+  }
+  return replacement;
+}
 async function determineParentAndIndexResolutionForResolver({
   core: core2,
   component,
@@ -57226,16 +57241,11 @@ async function expandCompositeComponent({
   }
   if (result2.replacements) {
     let serializedReplacements = result2.replacements;
-    await addReplacementsToResolver({
-      core: core2,
-      serializedReplacements,
-      component
-    });
-    reserveComponentIndices(core2, newNComponents);
     await createAndSetReplacements({
       core: core2,
       component,
-      serializedReplacements
+      serializedReplacements,
+      newNComponents
     });
   } else {
     throw Error(
@@ -57424,16 +57434,11 @@ async function expandShadowingComposite({
     );
   }
   component.replacementsWorkspace.replacementsCreated = stateIdInfo.num;
-  await addReplacementsToResolver({
-    core: core2,
-    serializedReplacements,
-    component
-  });
-  reserveComponentIndices(core2, newNComponents);
   await createAndSetReplacements({
     core: core2,
     component,
-    serializedReplacements
+    serializedReplacements,
+    newNComponents
   });
   if (shadowedComposite.replacementsToWithhold > 0) {
     component.replacementsToWithhold = shadowedComposite.replacementsToWithhold;
@@ -57482,30 +57487,49 @@ function adjustForCreateComponentIdxName({
 async function createAndSetReplacements({
   core: core2,
   component,
-  serializedReplacements
+  serializedReplacements,
+  newNComponents
 }) {
-  core2.parameterStack.push(component.sharedParameters, false);
+  reserveComponentIndices(core2, newNComponents);
+  let registrationFailure = null;
   try {
-    let replacementResult = await createIsolatedComponents({
+    await addReplacementsToResolver({
       core: core2,
-      serializedComponents: serializedReplacements,
-      ancestors: component.ancestors,
-      shadow: true,
-      componentsReplacementOf: component
+      serializedReplacements,
+      component
     });
-    component.replacements = replacementResult.components;
   } catch (e32) {
-    console.error(e32);
-    component.replacements = await core2.setErrorReplacements({
-      composite: component,
-      message: e32.message,
-      source: e32
-    });
+    registrationFailure = e32;
+  }
+  core2.parameterStack.push(component.sharedParameters, false);
+  if (registrationFailure) {
+    await setReplacementsToError(core2, component, registrationFailure);
+  } else {
+    try {
+      let replacementResult = await createIsolatedComponents({
+        core: core2,
+        serializedComponents: serializedReplacements,
+        ancestors: component.ancestors,
+        shadow: true,
+        componentsReplacementOf: component
+      });
+      component.replacements = replacementResult.components;
+    } catch (e32) {
+      await setReplacementsToError(core2, component, e32);
+    }
   }
   core2.parameterStack.pop();
   await core2.dependencies.addBlockersFromChangedReplacements(component);
   component.isExpanded = true;
 }
+async function setReplacementsToError(core2, component, e32) {
+  console.error(e32);
+  component.replacements = await core2.setErrorReplacements({
+    composite: component,
+    message: e32.message,
+    source: e32
+  });
+}
 async function replaceCompositeChildren({
   core: core2,
   parent
@@ -70179,18 +70203,18 @@ class CompositeReplacementUpdater {
           overwriteDoenetMLRange
         });
         const newNComponents = change.nComponents;
-        await addReplacementsToResolver({
-          core: this.core,
-          serializedReplacements,
-          component,
-          updateOldReplacementsStart,
-          updateOldReplacementsEnd,
-          blankStringReplacements
-        });
         if (newNComponents > this.core._components.length) {
           this.core._components[newNComponents - 1] = void 0;
         }
         try {
+          await addReplacementsToResolver({
+            core: this.core,
+            serializedReplacements,
+            component,
+            updateOldReplacementsStart,
+            updateOldReplacementsEnd,
+            blankStringReplacements
+          });
           const createResult = await createIsolatedComponents({
             core: this.core,
             serializedComponents: serializedReplacements,
@@ -70385,7 +70409,18 @@ class CompositeReplacementUpdater {
     };
     return results;
   }
-  async setErrorReplacements({
+  /**
+   * Report `message` against `composite` and stop the composite being
+   * updated again.
+   *
+   * This is the half of `setErrorReplacements` that does not touch the
+   * composite's replacements, for the caller that has nowhere to put an
+   * `_error` component: a composite that fails partway through *changing*
+   * its replacements already has some, and the machinery that would splice
+   * new ones in is the machinery that just failed. Reporting and standing
+   * still leaves the reader the page and the message.
+   */
+  markCompositeInError({
     composite,
     message,
     source
@@ -70397,6 +70432,14 @@ class CompositeReplacementUpdater {
       position: composite.position,
       sourceDoc: composite.sourceDoc
     });
+    composite.isInErrorState = true;
+  }
+  async setErrorReplacements({
+    composite,
+    message,
+    source
+  }) {
+    this.markCompositeInError({ composite, message, source });
     let errorReplacements = [
       {
         type: "serialized",
@@ -70413,7 +70456,6 @@ class CompositeReplacementUpdater {
       }
     ];
     this.core._components[this.core._components.length] = void 0;
-    composite.isInErrorState = true;
     let createResult = await createIsolatedComponents({
       core: this.core,
       serializedComponents: errorReplacements,
@@ -70635,35 +70677,36 @@ class CompositeReplacementUpdater {
           serializedReplacements: newSerializedReplacements,
           composite: shadowingComponent
         });
-        await addReplacementsToResolver({
-          core: this.core,
-          serializedReplacements: newSerializedReplacements,
-          component: shadowingComponent,
-          updateOldReplacementsStart,
-          updateOldReplacementsEnd,
-          blankStringReplacements
-        });
         if (newNComponents > this.core._components.length) {
           this.core._components[newNComponents - 1] = void 0;
         }
-        newSerializedReplacements = postProcessCopy({
-          serializedComponents: newSerializedReplacements,
-          componentIdx: shadowingComponent.shadows.compositeIdx
-        });
-        if (shadowingComponent.attributes.isResponse) {
-          let compositeAttributesObj = preprocessAttributesObject(
-            shadowingComponent.constructor.createAttributesObject()
-          );
-          for (let repl of newSerializedReplacements) {
-            if (typeof repl !== "object") {
-              continue;
-            }
-            if (!repl.attributes) {
-              repl.attributes = {};
-            }
-            let nComponents2 = this.core._components.length;
-            const res = convertUnresolvedAttributesForComponentType(
-              {
+        let registrationFailure = null;
+        try {
+          await addReplacementsToResolver({
+            core: this.core,
+            serializedReplacements: newSerializedReplacements,
+            component: shadowingComponent,
+            updateOldReplacementsStart,
+            updateOldReplacementsEnd,
+            blankStringReplacements
+          });
+          newSerializedReplacements = postProcessCopy({
+            serializedComponents: newSerializedReplacements,
+            componentIdx: shadowingComponent.shadows.compositeIdx
+          });
+          if (shadowingComponent.attributes.isResponse) {
+            let compositeAttributesObj = preprocessAttributesObject(
+              shadowingComponent.constructor.createAttributesObject()
+            );
+            for (let repl of newSerializedReplacements) {
+              if (typeof repl !== "object") {
+                continue;
+              }
+              if (!repl.attributes) {
+                repl.attributes = {};
+              }
+              let nComponents2 = this.core._components.length;
+              const res = convertUnresolvedAttributesForComponentType({
                 attributes: {
                   isResponse: shadowingComponent.attributes.isResponse
                 },
@@ -70671,15 +70714,20 @@ class CompositeReplacementUpdater {
                 componentInfoObjects: this.core.componentInfoObjects,
                 compositeAttributesObj,
                 nComponents: nComponents2
+              });
+              const attributesFromComposite = res.attributes;
+              nComponents2 = res.nComponents;
+              if (nComponents2 > this.core._components.length) {
+                this.core._components[nComponents2 - 1] = void 0;
               }
-            );
-            const attributesFromComposite = res.attributes;
-            nComponents2 = res.nComponents;
-            if (nComponents2 > this.core._components.length) {
-              this.core._components[nComponents2 - 1] = void 0;
+              Object.assign(
+                repl.attributes,
+                attributesFromComposite
+              );
             }
-            Object.assign(repl.attributes, attributesFromComposite);
           }
+        } catch (e32) {
+          registrationFailure = e32;
         }
         let newComponents;
         let unproxiedShadowingComponent = this.core._components[shadowingComponent.componentIdx];
@@ -70687,21 +70735,30 @@ class CompositeReplacementUpdater {
           unproxiedShadowingComponent.sharedParameters,
           false
         );
-        try {
-          let createResult = await createIsolatedComponents({
-            core: this.core,
-            serializedComponents: newSerializedReplacements,
-            ancestors: shadowingComponent.ancestors,
-            componentsReplacementOf: shadowingComponent
-          });
-          newComponents = createResult.components;
-        } catch (e32) {
-          console.error(e32);
+        if (registrationFailure) {
+          console.error(registrationFailure);
           newComponents = await this.setErrorReplacements({
             composite: shadowingComponent,
-            message: e32.message,
-            source: e32
+            message: registrationFailure.message,
+            source: registrationFailure
           });
+        } else {
+          try {
+            let createResult = await createIsolatedComponents({
+              core: this.core,
+              serializedComponents: newSerializedReplacements,
+              ancestors: shadowingComponent.ancestors,
+              componentsReplacementOf: shadowingComponent
+            });
+            newComponents = createResult.components;
+          } catch (e32) {
+            console.error(e32);
+            newComponents = await this.setErrorReplacements({
+              composite: shadowingComponent,
+              message: e32.message,
+              source: e32
+            });
+          }
         }
         this.core.parameterStack.pop();
         let shadowingParent;
@@ -70806,41 +70863,54 @@ class CompositeReplacementUpdater {
       componentChanges.push(newChange);
     }
     if (adjustResolver) {
-      const blankStringReplacements = component.replacements.map(
-        (repl) => typeof repl === "string" && repl.trim() === ""
-      );
-      const { indexResolution } = await determineParentAndIndexResolutionForResolver({
-        core: this.core,
-        component,
-        updateOldReplacementsStart: 0,
-        updateOldReplacementsEnd: component.replacements.length - (component.replacementsToWithhold ?? 0),
-        blankStringReplacements
-      });
-      let indexParent = indexResolution.ReplaceAll?.parent ?? indexResolution.ReplaceRange?.parent ?? null;
-      if (indexParent !== null && indexParent !== component.componentIdx) {
-        const indexParentComposite = this.core._components[indexParent];
-        if (indexParentComposite) {
-          if (this.core.replaceIndexResolutionsInResolver) {
-            const newContentForIndex = component.replacements.slice(
-              0,
-              component.replacements.length - change.replacementsToWithhold
-            ).map((repl) => {
-              if (typeof repl === "string") {
-                return repl;
-              } else {
-                return repl.componentIdx;
-              }
-            });
-            this.core.replaceIndexResolutionsInResolver(
-              { content: newContentForIndex },
-              indexResolution
-            );
-            this.core.rootNames = this.core.calculateRootNames?.().names;
-            await this.core.dependencies.addBlockersFromChangedReplacements(
-              indexParentComposite
-            );
+      let indexParentComposite = null;
+      try {
+        const blankStringReplacements = component.replacements.map(
+          (repl) => typeof repl === "string" && repl.trim() === ""
+        );
+        const { indexResolution } = await determineParentAndIndexResolutionForResolver({
+          core: this.core,
+          component,
+          updateOldReplacementsStart: 0,
+          updateOldReplacementsEnd: component.replacements.length - (component.replacementsToWithhold ?? 0),
+          blankStringReplacements
+        });
+        let indexParent = indexResolution.ReplaceAll?.parent ?? indexResolution.ReplaceRange?.parent ?? null;
+        if (indexParent !== null && indexParent !== component.componentIdx) {
+          const candidate = this.core._components[indexParent];
+          if (candidate) {
+            if (this.core.replaceIndexResolutionsInResolver) {
+              const newContentForIndex = component.replacements.slice(
+                0,
+                component.replacements.length - change.replacementsToWithhold
+              ).map((repl) => {
+                if (typeof repl === "string") {
+                  return repl;
+                } else {
+                  return repl.componentIdx;
+                }
+              });
+              this.core.replaceIndexResolutionsInResolver(
+                { content: newContentForIndex },
+                indexResolution
+              );
+              this.core.rootNames = this.core.calculateRootNames?.().names;
+              indexParentComposite = candidate;
+            }
           }
         }
+      } catch (e32) {
+        console.error(e32);
+        this.markCompositeInError({
+          composite: component,
+          message: e32.message,
+          source: e32
+        });
+      }
+      if (indexParentComposite) {
+        await this.core.dependencies.addBlockersFromChangedReplacements(
+          indexParentComposite
+        );
       }
     }
     component.replacementsToWithhold = replacementsToWithhold;
@@ -70848,6 +70918,9 @@ class CompositeReplacementUpdater {
       component
     );
     for (const shadowingComponent of iterateExpandableShadows(component)) {
+      if (!shadowingComponent.isExpanded) {
+        continue;
+      }
       await this.adjustReplacementsToWithhold({
         component: shadowingComponent,
         change,
@@ -248702,4 +248775,4 @@ export {
   getDefaultExportFromCjs$1 as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-DGyduyFg.js.map
+//# sourceMappingURL=index-DAy9ScBT.js.map