@doenet/v06-to-v07 0.7.20-dev.330 → 0.7.20-dev.332

package/{index-JU3SUcVk.js → index-LkbHGDuM.js}

@@ -40963,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-Cg26uPd_-CKeRbA2J.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-DacUQVtr-D1w1icgH.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -50415,8 +50415,11 @@ function normalizeArrayStateVariableDefaults(def, varName) {
   if (!def.returnEntryDimensions) {
     def.returnEntryDimensions = defaultReturnEntryDimensions;
   }
-  if (def.shadowingInstructions && !def.shadowingInstructions.returnWrappingComponents) {
-    def.shadowingInstructions.returnWrappingComponents = defaultReturnWrappingComponents;
+  if (def.shadowingInstructions) {
+    if (!def.shadowingInstructions.returnWrappingComponents) {
+      def.shadowingInstructions.returnWrappingComponents = defaultReturnWrappingComponents;
+    }
+    def.wrappingComponents = def.shadowingInstructions.returnWrappingComponents();
   }
 }
 function arraySizeDefinition({ dependencyValues }) {
@@ -50488,7 +50491,7 @@ async function initializeComponentStateVariables({
       component.stateVarAliases[stateVariable] = component.state[stateVariable].targetVariableName;
       delete component.state[stateVariable];
     } else {
-      await initializeStateVariable({
+      initializeStateVariablePlaceholder({
         core: core2,
         component,
         stateVariable
@@ -50496,6 +50499,109 @@ async function initializeComponentStateVariables({
     }
   }
 }
+function initializeStateVariablePlaceholder({
+  core: core2,
+  component,
+  stateVariable
+}) {
+  const stateVarObj = component.state[stateVariable];
+  stateVarObj.svComponent = component;
+  stateVarObj.svVarName = stateVariable;
+  stateVarObj.isResolved = false;
+  installStaleValueGetter(stateVarObj);
+  if (stateVarObj.isArray) {
+    if (!component.arrayEntryPrefixes) {
+      component.arrayEntryPrefixes = {};
+    }
+    const entryPrefixes = stateVarObj.entryPrefixes ?? [stateVariable];
+    for (const prefix of entryPrefixes) {
+      component.arrayEntryPrefixes[prefix] = stateVariable;
+    }
+  }
+  if (stateVarObj.triggerActionOnChange) {
+    let componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx];
+    if (!componentTriggers) {
+      componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx] = {};
+    }
+    componentTriggers[stateVariable] = {
+      action: stateVarObj.triggerActionOnChange
+    };
+  }
+}
+async function ensureStateVariableMaterialized({
+  core: core2,
+  component,
+  stateVariable
+}) {
+  const stateVarObj = component.state[stateVariable];
+  if (!stateVarObj || stateVarObj.svMaterialized || stateVarObj.isArrayEntry) {
+    return;
+  }
+  materializeNestedDefinitionFields(stateVarObj);
+  applyPendingShadowModification(stateVarObj);
+  const allStateVariablesAffected = [stateVariable];
+  if (stateVarObj.additionalStateVariablesDefined) {
+    allStateVariablesAffected.push(
+      ...stateVarObj.additionalStateVariablesDefined
+    );
+  }
+  for (const varName of allStateVariablesAffected) {
+    const obj = component.state[varName];
+    if (obj) {
+      obj.svMaterialized = true;
+    }
+  }
+  core2.dependencies.numMaterializedStateVariables += allStateVariablesAffected.length;
+  let workspace;
+  for (const varName of allStateVariablesAffected) {
+    const obj = component.state[varName];
+    if (!obj) {
+      continue;
+    }
+    if (varName !== stateVariable) {
+      materializeNestedDefinitionFields(obj);
+      applyPendingShadowModification(obj);
+    }
+    if (obj.createWorkspace) {
+      if (!workspace) {
+        workspace = {};
+      }
+      obj.workspace = workspace;
+    }
+    await initializeStateVariable({
+      core: core2,
+      component,
+      stateVariable: varName
+    });
+  }
+}
+function materializeNestedDefinitionFields(stateVarObj) {
+  if (stateVarObj.shadowingInstructions && !Object.prototype.hasOwnProperty.call(
+    stateVarObj,
+    "shadowingInstructions"
+  )) {
+    stateVarObj.shadowingInstructions = Object.assign(
+      {},
+      stateVarObj.shadowingInstructions
+    );
+  }
+  if (stateVarObj.additionalStateVariablesDefined && !Object.prototype.hasOwnProperty.call(
+    stateVarObj,
+    "additionalStateVariablesDefined"
+  )) {
+    stateVarObj.additionalStateVariablesDefined = [
+      ...stateVarObj.additionalStateVariablesDefined
+    ];
+  }
+  if (stateVarObj.stateVariablesDeterminingDependencies && !Object.prototype.hasOwnProperty.call(
+    stateVarObj,
+    "stateVariablesDeterminingDependencies"
+  )) {
+    stateVarObj.stateVariablesDeterminingDependencies = [
+      ...stateVarObj.stateVariablesDeterminingDependencies
+    ];
+  }
+}
 async function initializeStateVariable({
   core: core2,
   component,
@@ -50510,6 +50616,7 @@ async function initializeStateVariable({
   stateVarObj.svComponent = component;
   stateVarObj.svVarName = stateVariable;
   stateVarObj.isResolved = false;
+  stateVarObj.svMaterialized = true;
   installStaleValueGetter(stateVarObj);
   if (arrayEntryPrefix !== void 0) {
     await initializeArrayEntryStateVariable({
@@ -50532,9 +50639,11 @@ async function initializeStateVariable({
     if (!componentTriggers) {
       componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx] = {};
     }
-    componentTriggers[stateVariable] = {
-      action: stateVarObj.triggerActionOnChange
-    };
+    if (!componentTriggers[stateVariable]) {
+      componentTriggers[stateVariable] = {
+        action: stateVarObj.triggerActionOnChange
+      };
+    }
   }
 }
 async function initializeArrayEntryStateVariable({
@@ -50724,12 +50833,7 @@ async function initializeArrayStateVariable({
   if (!stateVarObj.returnEntryDimensions) {
     stateVarObj.returnEntryDimensions = defaultReturnEntryDimensions;
   }
-  if (stateVarObj.shadowingInstructions) {
-    if (!stateVarObj.shadowingInstructions.returnWrappingComponents) {
-      stateVarObj.shadowingInstructions.returnWrappingComponents = defaultReturnWrappingComponents;
-    }
-    stateVarObj.wrappingComponents = stateVarObj.shadowingInstructions.returnWrappingComponents();
-  }
+  if (stateVarObj.shadowingInstructions) ;
   stateVarObj.usedDefaultByArrayKey = {};
   stateVarObj.arrayEntryNames = [];
   stateVarObj.varNamesIncludingArrayKeys = {};
@@ -50902,25 +51006,8 @@ function getClassStateVariableDefinitions(core2, componentClass) {
   }
   return entry;
 }
-function cloneStateVariableDefinition(def) {
-  const clone2 = Object.assign({}, def);
-  if (clone2.shadowingInstructions) {
-    clone2.shadowingInstructions = Object.assign(
-      {},
-      clone2.shadowingInstructions
-    );
-  }
-  if (clone2.additionalStateVariablesDefined) {
-    clone2.additionalStateVariablesDefined = [
-      ...clone2.additionalStateVariablesDefined
-    ];
-  }
-  if (clone2.stateVariablesDeterminingDependencies) {
-    clone2.stateVariablesDeterminingDependencies = [
-      ...clone2.stateVariablesDeterminingDependencies
-    ];
-  }
-  return clone2;
+function wrapStateVariableDefinition(def) {
+  return Object.create(def);
 }
 async function createStateVariableDefinitions({
   core: core2,
@@ -50974,7 +51061,7 @@ async function createStateVariableDefinitions({
   }
   let stateVariableDefinitions = {};
   for (const varName in classDefinitions.normalized) {
-    stateVariableDefinitions[varName] = cloneStateVariableDefinition(
+    stateVariableDefinitions[varName] = wrapStateVariableDefinition(
       classDefinitions.normalized[varName]
     );
   }
@@ -51594,34 +51681,52 @@ function modifyStateDefsToBeShadows({
         }
       }
     }
-    delete stateDef.additionalStateVariablesDefined;
-    if (!foundReadyToExpandWhenResolved) {
-      delete stateDef.stateVariablesDeterminingDependencies;
-    }
-    let copyComponentType = stateDef.public && stateDef.shadowingInstructions.hasVariableComponentType;
-    stateDef.shadowOfComponentIdx = targetComponent.componentIdx;
-    stateDef.shadowVarName = varName;
-    stateDef.shadowCopyComponentType = copyComponentType;
-    if (stateDef.isArray) {
-      stateDef.shadowOverrideVarName = differentStateVariablesInTarget[varInd];
-      stateDef.returnArrayDependenciesByKey = shadowReturnArrayDependenciesByKey;
-      stateDef.arrayDefinitionByKey = shadowArrayDefinitionByKey;
-      stateDef.inverseArrayDefinitionByKey = shadowInverseArrayDefinitionByKey;
+    stateDef.svShadowParams = {
+      targetComponentIdx: targetComponent.componentIdx,
+      overrideVarName: differentStateVariablesInTarget[varInd],
+      keepOriginalDependencies: Boolean(foundReadyToExpandWhenResolved)
+    };
+  }
+  for (let varName in deleteStateVariablesFromDefinition) {
+    stateVariableDefinitions[varName].svShadowDeleteVars = deleteStateVariablesFromDefinition[varName];
+  }
+}
+function applyPendingShadowModification(stateVarObj) {
+  const params = stateVarObj.svShadowParams;
+  if (params) {
+    delete stateVarObj.svShadowParams;
+    const varName = stateVarObj.svVarName;
+    const originalReturnDependencies = stateVarObj.returnDependencies;
+    stateVarObj.additionalStateVariablesDefined = void 0;
+    if (!params.keepOriginalDependencies) {
+      stateVarObj.stateVariablesDeterminingDependencies = void 0;
+    }
+    let copyComponentType = stateVarObj.public && stateVarObj.shadowingInstructions.hasVariableComponentType;
+    stateVarObj.shadowOfComponentIdx = params.targetComponentIdx;
+    stateVarObj.shadowVarName = varName;
+    stateVarObj.shadowCopyComponentType = copyComponentType;
+    if (stateVarObj.isArray) {
+      stateVarObj.shadowOverrideVarName = params.overrideVarName;
+      stateVarObj.returnArrayDependenciesByKey = shadowReturnArrayDependenciesByKey;
+      stateVarObj.arrayDefinitionByKey = shadowArrayDefinitionByKey;
+      stateVarObj.inverseArrayDefinitionByKey = shadowInverseArrayDefinitionByKey;
     } else {
-      if (foundReadyToExpandWhenResolved) {
-        stateDef.shadowOriginalReturnDependencies = stateDef.returnDependencies.bind(stateDef);
+      if (params.keepOriginalDependencies) {
+        stateVarObj.shadowOriginalReturnDependencies = originalReturnDependencies.bind(stateVarObj);
       }
-      stateDef.shadowVarNameInTarget = differentStateVariablesInTarget[varInd] || varName;
-      stateDef.returnDependencies = shadowReturnDependencies;
-      stateDef.definition = shadowDefinition;
-      stateDef.excludeDependencyValuesInInverseDefinition = true;
-      stateDef.inverseDefinition = shadowInverseDefinition;
+      stateVarObj.shadowVarNameInTarget = params.overrideVarName || varName;
+      stateVarObj.returnDependencies = shadowReturnDependencies;
+      stateVarObj.definition = shadowDefinition;
+      stateVarObj.excludeDependencyValuesInInverseDefinition = true;
+      stateVarObj.inverseDefinition = shadowInverseDefinition;
     }
   }
-  for (let varName in deleteStateVariablesFromDefinition) {
+  const deleteVars = stateVarObj.svShadowDeleteVars;
+  if (deleteVars) {
+    delete stateVarObj.svShadowDeleteVars;
     modifyStateDefToDeleteVariableReferences({
-      varNamesToDelete: deleteStateVariablesFromDefinition[varName],
-      stateDef: stateVariableDefinitions[varName]
+      varNamesToDelete: deleteVars,
+      stateDef: stateVarObj
     });
   }
 }
@@ -53411,15 +53516,29 @@ const _Dependency = class _Dependency2 {
         componentClass: downComponent.constructor
       });
       if (this.constructor.convertToArraySize) {
-        mappedVarNames = mappedVarNames.map(function(vName) {
+        const convertedVarNames = [];
+        for (const vName of mappedVarNames) {
           let stateVarObj = downComponent.state[vName];
           if (stateVarObj) {
+            if (stateVarObj.isArray) {
+              await ensureStateVariableMaterialized({
+                core: this.dependencyHandler.core,
+                component: downComponent,
+                stateVariable: vName
+              });
+            }
             if (stateVarObj.arraySizeStateVariable) {
-              return stateVarObj.arraySizeStateVariable;
+              convertedVarNames.push(
+                stateVarObj.arraySizeStateVariable
+              );
             } else {
-              return `__${vName}_is_not_an_array`;
+              convertedVarNames.push(
+                `__${vName}_is_not_an_array`
+              );
             }
+            continue;
           }
+          let converted = `__${vName}_is_not_an_array`;
           if (downComponent.arrayEntryPrefixes) {
             let arrayEntryPrefixesLongestToShortest = Object.keys(
               downComponent.arrayEntryPrefixes
@@ -53436,13 +53555,20 @@ const _Dependency = class _Dependency2 {
                   numDimensions: arrayStateVarObj.numDimensions
                 });
                 if (arrayKeys.length > 0) {
-                  return downComponent.state[arrayVariableName].arraySizeStateVariable;
+                  await ensureStateVariableMaterialized({
+                    core: this.dependencyHandler.core,
+                    component: downComponent,
+                    stateVariable: arrayVariableName
+                  });
+                  converted = downComponent.state[arrayVariableName].arraySizeStateVariable;
+                  break;
                 }
               }
             }
           }
-          return `__${vName}_is_not_an_array`;
-        });
+          convertedVarNames.push(converted);
+        }
+        mappedVarNames = convertedVarNames;
       }
       if (this.propIndex !== void 0) {
         mappedVarNames = await arrayEntryNamesFromPropIndex({
@@ -58822,6 +58948,7 @@ class DependencyHandler {
       resolveBlockedBy: {}
     };
     this.numDependencySetups = 0;
+    this.numMaterializedStateVariables = 0;
     this.attributeRefResolutionDependenciesByReferenced = {};
     this._internedVariableNameLists = /* @__PURE__ */ new Map();
     this._internedComponentIndexLists = /* @__PURE__ */ new Map();
@@ -59001,6 +59128,11 @@ class DependencyHandler {
     if (!downDepsForComponent || downDepsForComponent[stateVariable] !== void 0) {
       return;
     }
+    await ensureStateVariableMaterialized({
+      core: this.core,
+      component,
+      stateVariable
+    });
     const allStateVariablesAffected = [stateVariable];
     if (stateVarObj.additionalStateVariablesDefined) {
       allStateVariablesAffected.push(
@@ -62546,6 +62678,13 @@ class EssentialValueWriter {
       let newComponentStateVariables = newStateVariableValues[cIdx];
       for (let vName in newComponentStateVariables) {
         let compStateObj = comp.state[vName];
+        if (compStateObj) {
+          await ensureStateVariableMaterialized({
+            core: this.core,
+            component: comp,
+            stateVariable: vName
+          });
+        }
         if (compStateObj === void 0) {
           let match2 = vName.match(/^__def_primitive_(\d+)$/);
           if (!match2 && newComponent) {
@@ -62691,6 +62830,11 @@ class EssentialValueWriter {
     }
     let componentWorkspace = workspace[instruction.componentIdx];
     let stateVarObj = component.state[stateVariable];
+    await ensureStateVariableMaterialized({
+      core: this.core,
+      component,
+      stateVariable
+    });
     let additionalStateVariablesDefined = stateVarObj.additionalStateVariablesDefined;
     let allStateVariablesAffected = [stateVariable];
     if (additionalStateVariablesDefined) {
@@ -64053,6 +64197,11 @@ class StalenessPropagator {
     for (let arrayEntryPrefix of arrayEntryPrefixesLongestToShortest) {
       if (stateVariable.substring(0, arrayEntryPrefix.length) === arrayEntryPrefix) {
         let arrayVariableName = component.arrayEntryPrefixes[arrayEntryPrefix];
+        await ensureStateVariableMaterialized({
+          core: this.core,
+          component,
+          stateVariable: arrayVariableName
+        });
         let arrayStateVarObj = component.state[arrayVariableName];
         let arrayKeys = arrayStateVarObj.getArrayKeysFromVarName({
           arrayEntryPrefix,
@@ -64809,6 +64958,11 @@ class StateVariableEvaluator {
         `Can't get value of ${stateVariable} of ${component.componentIdx} as it doesn't exist.`
       );
     }
+    await ensureStateVariableMaterialized({
+      core: this.core,
+      component,
+      stateVariable
+    });
     if (component.reprocessAfterEvaluate) {
       let reprocessAfterEvaluate = component.reprocessAfterEvaluate;
       delete component.reprocessAfterEvaluate;
@@ -69012,51 +69166,15 @@ class BaseComponent {
     this.state = {};
     if (stateVariableDefinitions[SHARED_STATE_VARIABLE_DEFINITIONS]) {
       for (let stateVariable in stateVariableDefinitions) {
-        let def = Object.create(
+        this.state[stateVariable] = Object.create(
           stateVariableDefinitions[stateVariable]
         );
-        if (def.shadowingInstructions) {
-          def.shadowingInstructions = Object.assign(
-            {},
-            def.shadowingInstructions
-          );
-        }
-        if (def.additionalStateVariablesDefined) {
-          def.additionalStateVariablesDefined = [
-            ...def.additionalStateVariablesDefined
-          ];
-        }
-        if (def.stateVariablesDeterminingDependencies) {
-          def.stateVariablesDeterminingDependencies = [
-            ...def.stateVariablesDeterminingDependencies
-          ];
-        }
-        this.state[stateVariable] = def;
       }
     } else {
       for (let stateVariable in stateVariableDefinitions) {
         this.state[stateVariable] = stateVariableDefinitions[stateVariable];
       }
     }
-    let workspaceAssigned = /* @__PURE__ */ new Set();
-    for (let stateVariable in this.state) {
-      let def = this.state[stateVariable];
-      if (!def.createWorkspace || workspaceAssigned.has(stateVariable)) {
-        continue;
-      }
-      let workspace = {};
-      def.workspace = workspace;
-      workspaceAssigned.add(stateVariable);
-      if (def.additionalStateVariablesDefined) {
-        for (let otherVar of def.additionalStateVariablesDefined) {
-          let otherDef = this.state[otherVar];
-          if (otherDef?.createWorkspace) {
-            otherDef.workspace = workspace;
-            workspaceAssigned.add(otherVar);
-          }
-        }
-      }
-    }
     this.stateValues = new Proxy(this.state, createStateProxyHandler());
     this.essentialState = {};
     if (serializedComponent.state) {
@@ -229391,4 +229509,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-JU3SUcVk.js.map
+//# sourceMappingURL=index-LkbHGDuM.js.map