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

package/{index-BmXW0q7U.js → index-Bur65SYm.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-Cy4MoSBb-D7vYyaIg.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-C8N7qkQo-_aAug7Di.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -49616,6 +49616,54 @@ const PRIMITIVE_TO_COMPONENT_TYPE = {
   stringArray: "textList",
   numberArray: "numberList"
 };
+const SHARED_STATE_VARIABLE_DEFINITIONS = /* @__PURE__ */ Symbol(
+  "sharedStateVariableDefinitions"
+);
+const classStateVariableDefinitionsCache = /* @__PURE__ */ new WeakMap();
+function getClassStateVariableDefinitions(core2, componentClass) {
+  let perCore = classStateVariableDefinitionsCache.get(core2);
+  if (!perCore) {
+    perCore = /* @__PURE__ */ new Map();
+    classStateVariableDefinitionsCache.set(core2, perCore);
+  }
+  let entry = perCore.get(componentClass);
+  if (!entry) {
+    const combined = {};
+    createAttributeStateVariableDefinitions({
+      core: core2,
+      stateVariableDefinitions: combined,
+      componentClass
+    });
+    const normalized = componentClass.returnNormalizedStateVariableDefinitions(
+      core2.numerics
+    );
+    Object.assign(combined, normalized);
+    combined[SHARED_STATE_VARIABLE_DEFINITIONS] = true;
+    entry = { combined, normalized };
+    perCore.set(componentClass, entry);
+  }
+  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;
+}
 async function createStateVariableDefinitions({
   core: core2,
   componentClass,
@@ -49659,32 +49707,33 @@ async function createStateVariableDefinitions({
       }
     }
   }
-  let stateVariableDefinitions = {};
+  const classDefinitions = getClassStateVariableDefinitions(
+    core2,
+    componentClass
+  );
   if (!redefineDependencies) {
-    createAttributeStateVariableDefinitions({
+    return classDefinitions.combined;
+  }
+  let stateVariableDefinitions = {};
+  for (const varName in classDefinitions.normalized) {
+    stateVariableDefinitions[varName] = cloneStateVariableDefinition(
+      classDefinitions.normalized[varName]
+    );
+  }
+  if (redefineDependencies.linkSource === "adapter") {
+    createAdapterStateVariableDefinitions({
       core: core2,
+      redefineDependencies,
+      stateVariableDefinitions,
+      componentClass
+    });
+  } else {
+    await createReferenceShadowStateVariableDefinitions({
+      core: core2,
+      redefineDependencies,
       stateVariableDefinitions,
       componentClass
     });
-  }
-  let newDefinitions = componentClass.returnNormalizedStateVariableDefinitions(core2.numerics);
-  Object.assign(stateVariableDefinitions, newDefinitions);
-  if (redefineDependencies) {
-    if (redefineDependencies.linkSource === "adapter") {
-      createAdapterStateVariableDefinitions({
-        core: core2,
-        redefineDependencies,
-        stateVariableDefinitions,
-        componentClass
-      });
-    } else {
-      await createReferenceShadowStateVariableDefinitions({
-        core: core2,
-        redefineDependencies,
-        stateVariableDefinitions,
-        componentClass
-      });
-    }
   }
   return stateVariableDefinitions;
 }
@@ -53011,6 +53060,7 @@ function cloneChangeMetadataIfNeeded({
 }) {
   return consumeChanges ? changeMetadata : deepClone(changeMetadata);
 }
+const INITIAL_CHANGE_RECORD = Object.freeze({ changed: true });
 const _Dependency = class _Dependency2 {
   constructor({
     component,
@@ -53025,7 +53075,7 @@ const _Dependency = class _Dependency2 {
     this.dependencyHandler = dependencyHandler;
     this.upstreamComponentIdx = component.componentIdx;
     this.upstreamVariableNames = allStateVariablesAffected;
-    this.definition = Object.assign({}, dependencyDefinition);
+    this.definition = dependencyDefinition;
     this.representativeStateVariable = stateVariable;
     if (dependencyDefinition.doNotProxy) {
       this.doNotProxy = true;
@@ -53181,6 +53231,9 @@ const _Dependency = class _Dependency2 {
       }
       let downVarNames = mappedVarNames;
       if (originalVarNames.length > 0 || this.originalVariablesByComponent) {
+        mappedVarNames = this.dependencyHandler.internVariableNameList(
+          mappedVarNames
+        );
         this.mappedDownstreamVariableNamesByComponent.splice(
           index2,
           0,
@@ -53188,7 +53241,7 @@ const _Dependency = class _Dependency2 {
         );
         let valsChanged = {};
         for (let downVar of mappedVarNames) {
-          valsChanged[downVar] = { changed: true };
+          valsChanged[downVar] = INITIAL_CHANGE_RECORD;
         }
         this.valuesChanged.splice(index2, 0, valsChanged);
         if (this.variablesOptional) {
@@ -53288,9 +53341,10 @@ const _Dependency = class _Dependency2 {
         );
         this.valuesChanged.splice(indexToRemove, 1);
         if (this.variablesOptional) {
-          affectedDownstreamVariableNames.push(
+          affectedDownstreamVariableNames = [
+            ...affectedDownstreamVariableNames,
             this.downstreamVariableNameIfNoVariables
-          );
+          ];
         }
       }
       for (let vName of affectedDownstreamVariableNames) {
@@ -53511,7 +53565,7 @@ const _Dependency = class _Dependency2 {
               if (!mappedStateVarObj.deferred) {
                 componentObj.stateValues[nameForOutput] = await mappedStateVarObj.value;
                 let valueChanged = this.valuesChanged[componentInd][mappedVarName];
-                if (valueChanged.changed) {
+                if (valueChanged?.changed) {
                   if (!changes.valuesChanged) {
                     changes.valuesChanged = {};
                   }
@@ -53524,7 +53578,7 @@ const _Dependency = class _Dependency2 {
                   });
                 }
                 if (consumeChanges) {
-                  this.valuesChanged[componentInd][mappedVarName] = {};
+                  delete this.valuesChanged[componentInd][mappedVarName];
                 }
                 if (mappedStateVarObj.usedDefault) {
                   usedDefaultObj[nameForOutput] = true;
@@ -54093,7 +54147,7 @@ const _StateVariableComponentTypeDependency = class _StateVariableComponentTypeD
               }
             }
             let valueChanged0 = this.valuesChanged[0][mappedVarName];
-            if (valueChanged0.changed) {
+            if (valueChanged0?.changed) {
               if (!changes.valuesChanged) {
                 changes.valuesChanged = {};
               }
@@ -54106,7 +54160,7 @@ const _StateVariableComponentTypeDependency = class _StateVariableComponentTypeD
               });
             }
             if (consumeChanges) {
-              this.valuesChanged[0][mappedVarName] = {};
+              delete this.valuesChanged[0][mappedVarName];
             }
             let hasVariableComponentType = stateVarObj.shadowingInstructions?.hasVariableComponentType;
             if (!hasVariableComponentType && stateVarObj.isArrayEntry) {
@@ -58495,6 +58549,7 @@ const dependencyTypeClasses = [
   DetermineDependenciesDependency,
   FileDependency
 ];
+const EMPTY_BLOCKERS = Object.freeze({});
 class DependencyHandler {
   constructor({
     _components,
@@ -58529,6 +58584,16 @@ class DependencyHandler {
       resolveBlockedBy: {}
     };
     this.attributeRefResolutionDependenciesByReferenced = {};
+    this._internedVariableNameLists = /* @__PURE__ */ new Map();
+  }
+  internVariableNameList(names) {
+    const key = names.join("\n");
+    let interned = this._internedVariableNameLists.get(key);
+    if (!interned) {
+      interned = Object.freeze(names);
+      this._internedVariableNameLists.set(key, interned);
+    }
+    return interned;
   }
   async setUpComponentDependencies(component) {
     if (this.downstreamDependencies[component.componentIdx]) {
@@ -59244,26 +59309,11 @@ class DependencyHandler {
           let ind = upDep.downstreamComponentIndices.indexOf(componentIdx);
           let upValuesChanged = upDep.valuesChanged[ind][varName];
           if (!upValuesChanged) {
-            if (component.stateVarAliases) {
-              for (let alias in component.stateVarAliases) {
-                if (component.stateVarAliases[alias] === varName && // @ts-expect-error see "Note (dated July 20, 2023)" above:
-                // `upValuesChangedSub` is undefined; keeping the
-                // reference verbatim so behavior matches the JS source.
-                alias in upValuesChangedSub) {
-                  upValuesChanged = // @ts-expect-error same as above
-                  upValuesChangedSub[alias];
-                }
-              }
-            }
-          }
-          if (!upValuesChanged) {
-            if (!component.state[varName].isArrayEntry) {
-              throw Error(
-                `Something is wrong, as a variable ${varName} of ${component.componentIdx} actually changed, but wasn't marked with a potential change`
-              );
-            }
-            upValuesChanged = // @ts-expect-error same as above
-            upValuesChangedSub[varName] = { changed: {} };
+            upValuesChanged = upDep.valuesChanged[ind][varName] = {};
+          } else if (Object.isFrozen(upValuesChanged)) {
+            upValuesChanged = upDep.valuesChanged[ind][varName] = {
+              changed: upValuesChanged.changed
+            };
           }
           if (component.state[varName] && component.state[varName].isArray) {
             if (upValuesChanged.changed === void 0) {
@@ -59381,6 +59431,45 @@ class DependencyHandler {
       finishedPropagation: parentResult.finishedPropagation
     };
   }
+  /**
+   * Non-creating variant of `getNeededToResolve`: returns the nested entry
+   * if it exists, else `EMPTY_BLOCKERS`, without materializing intermediate
+   * levels. `getNeededToResolve` creates the whole nested chain on every
+   * lookup, and read-only callers used to leave tens of thousands of empty
+   * `{cIdx: {type: {stateVariable: {}}}}` chains behind — the bulk of
+   * `resolveBlockers`' retained memory.
+   */
+  peekNeededToResolve({
+    componentIdx,
+    type,
+    stateVariable,
+    dependency
+  }) {
+    let neededToResolve = this.resolveBlockers.neededToResolve[componentIdx]?.[type];
+    if (neededToResolve && stateVariable) {
+      neededToResolve = neededToResolve[stateVariable];
+      if (neededToResolve && dependency) {
+        neededToResolve = neededToResolve[dependency];
+      }
+    }
+    return neededToResolve ?? EMPTY_BLOCKERS;
+  }
+  /** Non-creating variant of `getResolveBlockedBy`; see `peekNeededToResolve`. */
+  peekResolveBlockedBy({
+    componentIdx,
+    type,
+    stateVariable,
+    dependency
+  }) {
+    let resolveBlockedBy = this.resolveBlockers.resolveBlockedBy[componentIdx]?.[type];
+    if (resolveBlockedBy && stateVariable) {
+      resolveBlockedBy = resolveBlockedBy[stateVariable];
+      if (resolveBlockedBy && dependency) {
+        resolveBlockedBy = resolveBlockedBy[dependency];
+      }
+    }
+    return resolveBlockedBy ?? EMPTY_BLOCKERS;
+  }
   getNeededToResolve({ componentIdx, type, stateVariable, dependency }) {
     let neededToResolveForComponent = this.resolveBlockers.neededToResolve[componentIdx];
     if (!neededToResolveForComponent) {
@@ -59890,7 +59979,7 @@ class DependencyHandler {
         } catch (e32) {
         }
         if (dep) {
-          let neededForItem = this.getNeededToResolve({
+          let neededForItem = this.peekNeededToResolve({
             componentIdx: componentIdxNewlyResolved,
             type: "stateVariable",
             stateVariable: stateVariableNewlyResolved
@@ -59981,7 +60070,7 @@ class DependencyHandler {
         );
       }
     }
-    let resolveBlockedByNewlyResolved = this.getResolveBlockedBy({
+    let resolveBlockedByNewlyResolved = this.peekResolveBlockedBy({
       componentIdx: componentIdxNewlyResolved,
       type: typeNewlyResolved,
       stateVariable: stateVariableNewlyResolved,
@@ -60083,7 +60172,7 @@ class DependencyHandler {
     expandComposites = true,
     numPreviouslyNeeded
   }) {
-    let neededForItem = this.getNeededToResolve({
+    let neededForItem = this.peekNeededToResolve({
       componentIdx,
       type,
       stateVariable,
@@ -60125,7 +60214,7 @@ class DependencyHandler {
         break;
       }
       if (nFailures > 0) {
-        neededForItem = this.getNeededToResolve({
+        neededForItem = this.peekNeededToResolve({
           componentIdx,
           type,
           stateVariable,
@@ -60165,7 +60254,7 @@ class DependencyHandler {
       }
     }
     if (nFailures > 0) {
-      neededForItem = this.getNeededToResolve({
+      neededForItem = this.peekNeededToResolve({
         componentIdx,
         type,
         stateVariable,
@@ -60213,7 +60302,7 @@ class DependencyHandler {
       expandComposites
     });
     if (!finalResult.success) {
-      let stillNeededForItem = this.getNeededToResolve({
+      let stillNeededForItem = this.peekNeededToResolve({
         componentIdx,
         type,
         stateVariable,
@@ -60265,7 +60354,7 @@ class DependencyHandler {
     }
     if (!this.circularResolveBlockedCheckPassed[identifier]) {
       this.circularResolveBlockedCheckPassed[identifier] = true;
-      let neededForItem = this.getNeededToResolve({
+      let neededForItem = this.peekNeededToResolve({
         componentIdx,
         type,
         stateVariable,
@@ -60380,7 +60469,7 @@ class DependencyHandler {
     let identifier = code + "|" + type;
     if (this.circularResolveBlockedCheckPassed[identifier]) {
       delete this.circularResolveBlockedCheckPassed[identifier];
-      let resolveBlockedBy = this.getResolveBlockedBy({
+      let resolveBlockedBy = this.peekResolveBlockedBy({
         componentIdx,
         type,
         stateVariable,
@@ -63834,12 +63923,13 @@ class StalenessPropagator {
             if (!upDep.valuesChanged[componentInd]) {
               upDep.valuesChanged[componentInd] = {};
             }
-            if (!upDep.valuesChanged[componentInd][varName]) {
-              upDep.valuesChanged[componentInd][varName] = {};
+            let changeRecord = upDep.valuesChanged[componentInd][varName];
+            if (!changeRecord || Object.isFrozen(changeRecord)) {
+              changeRecord = upDep.valuesChanged[componentInd][varName] = changeRecord ? { changed: changeRecord.changed } : {};
             }
-            upDep.valuesChanged[componentInd][varName].potentialChange = true;
+            changeRecord.potentialChange = true;
             if (freshnessInfo) {
-              upDep.valuesChanged[componentInd][varName].freshnessInfo = freshnessInfo;
+              changeRecord.freshnessInfo = freshnessInfo;
             }
             foundVarChange = true;
           } else if (varName === upDep.downstreamVariableNameIfNoVariables) {
@@ -68465,11 +68555,52 @@ class BaseComponent {
       this.refResolution = refResolution;
     }
     this.state = {};
-    for (let stateVariable in stateVariableDefinitions) {
-      this.state[stateVariable] = Object.assign(
-        {},
-        stateVariableDefinitions[stateVariable]
-      );
+    if (stateVariableDefinitions[SHARED_STATE_VARIABLE_DEFINITIONS]) {
+      for (let stateVariable in stateVariableDefinitions) {
+        let def = 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 = {};
@@ -73280,6 +73411,14 @@ class Label extends InlineComponent {
       public: true,
       forRenderer: true
     };
+    attributes.maskLabel = {
+      description: "Whether to give the label an opaque background so it stays legible when it overlaps an axis, grid line, or another object. Set to false to restore a transparent label background.",
+      createComponentOfType: "boolean",
+      createStateVariable: "maskLabel",
+      defaultValue: true,
+      public: true,
+      forRenderer: true
+    };
     Object.assign(attributes, returnAnchorAttributes());
     return attributes;
   }
@@ -81862,6 +82001,14 @@ class GraphicalComponent extends BaseComponent {
       forRenderer: true,
       description: "Whether to apply this component's selected style to its label."
     };
+    attributes.maskLabel = {
+      createComponentOfType: "boolean",
+      createStateVariable: "maskLabel",
+      defaultValue: true,
+      public: true,
+      forRenderer: true,
+      description: "Whether to give the label an opaque background so it stays legible when it overlaps an axis, grid line, or another object. Set to false to restore a transparent label background."
+    };
     attributes.layer = {
       createComponentOfType: "integer",
       createStateVariable: "layer",
@@ -228723,4 +228870,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-BmXW0q7U.js.map
+//# sourceMappingURL=index-Bur65SYm.js.map