@doenet/v06-to-v07 0.7.26-dev.540 → 0.7.26

package/{index-DYUgFZHa.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-Qy06UIn3-DoA6xmY7.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
       });
@@ -68088,8 +68088,12 @@ class DependencyHandler {
         stateVariable
       );
     }
-    const item = { componentIdx, type, stateVariable, dependency };
-    let neededForItem = this.peekNeededToResolve(item);
+    let neededForItem = this.peekNeededToResolve({
+      componentIdx,
+      type,
+      stateVariable,
+      dependency
+    });
     let determineDepsBlockers = neededForItem.determineDependencies;
     if (determineDepsBlockers && determineDepsBlockers.length > 0) {
       for (let blockerCode of [...determineDepsBlockers]) {
@@ -68119,62 +68123,115 @@ class DependencyHandler {
         stateVarObj.currentlyResolving = true;
       }
     }
-    try {
-      let previousNFailures = Infinity;
-      let nFailures = Infinity;
-      while (Object.keys(neededForItem).length > 0 || nFailures > 0) {
-        if (Number.isFinite(nFailures) && nFailures >= previousNFailures) {
-          break;
-        }
-        if (nFailures > 0) {
-          neededForItem = this.peekNeededToResolve(item);
-        }
-        previousNFailures = nFailures;
-        let passResult = await this._resolveBlockersOfItem({
-          neededForItem,
-          item,
-          forceBlockers: false,
-          tolerateFailures: force,
-          expandComposites
-        });
-        if (passResult.failure) {
-          return passResult.failure;
-        }
-        nFailures = passResult.nFailures;
+    let previousNFailures = Infinity;
+    let nFailures = Infinity;
+    while (Object.keys(neededForItem).length > 0 || nFailures > 0) {
+      if (Number.isFinite(nFailures) && nFailures >= previousNFailures) {
+        break;
       }
       if (nFailures > 0) {
-        neededForItem = this.peekNeededToResolve(item);
-        while (Object.keys(neededForItem).length > 0) {
-          let passResult = await this._resolveBlockersOfItem({
-            neededForItem,
-            item,
-            forceBlockers: force,
-            tolerateFailures: false,
+        neededForItem = this.peekNeededToResolve({
+          componentIdx,
+          type,
+          stateVariable,
+          dependency
+        });
+      }
+      previousNFailures = nFailures;
+      nFailures = 0;
+      for (let blockerType in neededForItem) {
+        if (blockerType === "determineDependencies") {
+          throw Error(
+            `Shouldn't have determine dependencies blocker after determining dependencies: ${componentIdx}, ${type}, ${stateVariable}, ${dependency}`
+          );
+        }
+        for (let code of [...neededForItem[blockerType]]) {
+          let [
+            blockerComponentIdx,
+            blockerStateVariable,
+            blockerDependency
+          ] = typeof code === "string" ? code.split("|") : [code];
+          let result2 = await this.resolveItem({
+            componentIdx: blockerComponentIdx,
+            type: blockerType,
+            stateVariable: blockerStateVariable,
+            dependency: blockerDependency,
+            //force, //recurseUpstream
             expandComposites
           });
-          if (passResult.failure) {
-            return passResult.failure;
+          if (!result2.success) {
+            if (force) {
+              nFailures++;
+            } else {
+              return result2;
+            }
           }
         }
       }
-    } finally {
-      if (stateVarObj) {
-        stateVarObj.currentlyResolving = false;
+    }
+    if (nFailures > 0) {
+      neededForItem = this.peekNeededToResolve({
+        componentIdx,
+        type,
+        stateVariable,
+        dependency
+      });
+      while (Object.keys(neededForItem).length > 0) {
+        for (let blockerType in neededForItem) {
+          if (blockerType === "determineDependencies") {
+            throw Error(
+              `Shouldn't have determine dependencies blocker after determining dependencies: ${componentIdx}, ${type}, ${stateVariable}, ${dependency}`
+            );
+          }
+          for (let code of [...neededForItem[blockerType]]) {
+            let [
+              blockerComponentIdx,
+              blockerStateVariable,
+              blockerDependency
+            ] = typeof code === "string" ? code.split("|") : [code];
+            let result2 = await this.resolveItem({
+              componentIdx: blockerComponentIdx,
+              type: blockerType,
+              stateVariable: blockerStateVariable,
+              dependency: blockerDependency,
+              force,
+              //recurseUpstream
+              expandComposites
+            });
+            if (!result2.success) {
+              return result2;
+            }
+          }
+        }
       }
     }
+    if (stateVarObj) {
+      stateVarObj.currentlyResolving = false;
+    }
     let finalResult = await this.resolveIfReady({
-      ...item,
+      componentIdx,
+      type,
+      stateVariable,
+      dependency,
       force,
       recurseUpstream,
       expandComposites
     });
     if (!finalResult.success) {
-      let stillNeededForItem = this.peekNeededToResolve(item);
+      let stillNeededForItem = this.peekNeededToResolve({
+        componentIdx,
+        type,
+        stateVariable,
+        dependency
+      });
       let numNeeded = Object.keys(stillNeededForItem).length;
       if (numNeeded > 0) {
         if (numPreviouslyNeeded === void 0 || numNeeded < numPreviouslyNeeded) {
           finalResult = await this.resolveItem({
-            ...item,
+            componentIdx,
+            type,
+            stateVariable,
+            dependency,
             force,
             recurseUpstream,
             expandComposites,
@@ -68185,61 +68242,6 @@ class DependencyHandler {
     }
     return finalResult;
   }
-  /**
-   * Make one pass over `neededForItem`, the live record of what is still
-   * blocking `item`, resolving each blocker in turn. Entries drop out of the
-   * record as their blockers resolve, so the caller can loop until it is
-   * empty.
-   *
-   * `forceBlockers` is passed on to each blocker's own `resolveItem`.
-   * `tolerateFailures` decides what an unresolved blocker means: when false,
-   * the pass stops and hands back that blocker's result as `failure` for the
-   * caller to propagate; when true, the pass continues and reports how many
-   * blockers failed as `nFailures`.
-   *
-   * A `determineDependencies` blocker reaching here is a bug, so it throws:
-   * `resolveItem` resolves those before it sets `currentlyResolving`, and
-   * that flag is what stops a new one from being added while it works.
-   */
-  async _resolveBlockersOfItem({
-    neededForItem,
-    item,
-    forceBlockers,
-    tolerateFailures,
-    expandComposites
-  }) {
-    let nFailures = 0;
-    for (let blockerType in neededForItem) {
-      if (blockerType === "determineDependencies") {
-        throw Error(
-          `Shouldn't have determine dependencies blocker after determining dependencies: ${item.componentIdx}, ${item.type}, ${item.stateVariable}, ${item.dependency}`
-        );
-      }
-      for (let code of [...neededForItem[blockerType]]) {
-        let [
-          blockerComponentIdx,
-          blockerStateVariable,
-          blockerDependency
-        ] = typeof code === "string" ? code.split("|") : [code];
-        let result2 = await this.resolveItem({
-          componentIdx: blockerComponentIdx,
-          type: blockerType,
-          stateVariable: blockerStateVariable,
-          dependency: blockerDependency,
-          force: forceBlockers,
-          expandComposites
-        });
-        if (!result2.success) {
-          if (tolerateFailures) {
-            nFailures++;
-          } else {
-            return { failure: result2, nFailures };
-          }
-        }
-      }
-    }
-    return { nFailures };
-  }
   checkForCircularResolveBlocker({
     componentIdx,
     type,
@@ -239467,4 +239469,4 @@ export {
   getDefaultExportFromCjs$1 as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-DYUgFZHa.js.map
+//# sourceMappingURL=index-Bin7pIAp.js.map