@doenet/v06-to-v07 0.7.21-dev.351 → 0.7.21-dev.353

package/{index-B7dZK3j_.js → index-L-CvJFQy.js}

@@ -40982,6 +40982,14 @@ function contrastAccessibilityDiagnosticsForStyleDefinitions(styleDefinitions) {
   }
   return diagnostics;
 }
+function resolveReaderPaletteName(overrides2) {
+  const raw = overrides2?.palette;
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const name2 = raw.trim().toLowerCase();
+  return name2 in STYLE_PALETTES ? name2 : null;
+}
 let styleAttributes$1 = {
   lineColor: {
     componentType: "text",
@@ -41498,6 +41506,77 @@ function childrenExpandingSetups(dependencyValues, mixedChildren, perSetupPrefix
   }
   return out;
 }
+function normalizeReaderStyleValue(key, value) {
+  switch (styleAttributes$1[key]?.componentType) {
+    case "number": {
+      const num = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+      return Number.isFinite(num) ? num : void 0;
+    }
+    case "boolean": {
+      if (typeof value === "boolean") {
+        return value;
+      }
+      if (typeof value === "string") {
+        const lowered = value.toLowerCase();
+        if (lowered === "true") {
+          return true;
+        }
+        if (lowered === "false") {
+          return false;
+        }
+      }
+      return void 0;
+    }
+    default:
+      return typeof value === "string" ? value.toLowerCase() : void 0;
+  }
+}
+function applyReaderStyleOverrides(styleDefinitions, overrides2) {
+  const hasOwn = Object.prototype.hasOwnProperty;
+  const readerPaletteName = resolveReaderPaletteName(overrides2);
+  if (readerPaletteName != null) {
+    for (const styleNumber of Object.keys(styleDefinitions)) {
+      delete styleDefinitions[styleNumber];
+    }
+    Object.assign(
+      styleDefinitions,
+      returnPaletteStyleDefinitions(readerPaletteName)
+    );
+  }
+  const styles = overrides2?.styles;
+  if (!styles || typeof styles !== "object") {
+    return;
+  }
+  for (const [styleNumber, valueOverrides] of Object.entries(styles)) {
+    if (!hasOwn.call(styleDefinitions, styleNumber)) {
+      continue;
+    }
+    const target = styleDefinitions[styleNumber];
+    if (!target || !valueOverrides || typeof valueOverrides !== "object") {
+      continue;
+    }
+    const block = {};
+    for (const [key, value] of Object.entries(valueOverrides)) {
+      if (!hasOwn.call(styleAttributes$1, key) || key.includes("Word")) {
+        continue;
+      }
+      const normalized = normalizeReaderStyleValue(
+        key,
+        value
+      );
+      if (normalized === void 0) {
+        continue;
+      }
+      setStyleValue(block, key, normalized);
+    }
+    if (Object.keys(block).length === 0) {
+      continue;
+    }
+    addMissingChildStyleColorFields(block);
+    deriveMissingStyleWords(block);
+    Object.assign(target, block);
+  }
+}
 function returnStyleDefinitionStateVariables() {
   let stateVariableDefinitions = {};
   stateVariableDefinitions.setupChildren = {
@@ -41514,6 +41593,56 @@ function returnStyleDefinitionStateVariables() {
       };
     }
   };
+  stateVariableDefinitions.readerStyleOverrides = {
+    hasEssential: true,
+    defaultValue: null,
+    returnDependencies: () => ({
+      documentAncestor: {
+        dependencyType: "ancestor",
+        componentType: "document",
+        variableNames: ["readerStyleOverrides"]
+      }
+    }),
+    definition({ dependencyValues }) {
+      if (dependencyValues.documentAncestor) {
+        return {
+          setValue: {
+            readerStyleOverrides: dependencyValues.documentAncestor.stateValues.readerStyleOverrides
+          }
+        };
+      } else {
+        return {
+          useEssentialOrDefaultValue: { readerStyleOverrides: true }
+        };
+      }
+    },
+    inverseDefinition({
+      desiredStateVariableValues,
+      dependencyValues
+    }) {
+      if (dependencyValues.documentAncestor) {
+        return {
+          success: true,
+          instructions: [
+            {
+              setDependency: "documentAncestor",
+              desiredValue: desiredStateVariableValues.readerStyleOverrides
+            }
+          ]
+        };
+      } else {
+        return {
+          success: true,
+          instructions: [
+            {
+              setEssentialValue: "readerStyleOverrides",
+              value: desiredStateVariableValues.readerStyleOverrides
+            }
+          ]
+        };
+      }
+    }
+  };
   stateVariableDefinitions.localStylePaletteName = {
     stateVariablesDeterminingDependencies: ["setupChildren"],
     returnDependencies({ stateValues }) {
@@ -41578,14 +41707,15 @@ function returnStyleDefinitionStateVariables() {
       return { setValue: { activeStylePaletteName } };
     }
   };
-  stateVariableDefinitions.styleDefinitions = {
+  stateVariableDefinitions.authoredStyleDefinitions = {
+    // Always evaluated so the diagnostics side effect reliably runs.
     mustEvaluate: true,
     stateVariablesDeterminingDependencies: ["setupChildren"],
     returnDependencies({ stateValues }) {
       let dependencies2 = {
         ancestorWithStyle: {
           dependencyType: "ancestor",
-          variableNames: ["styleDefinitions"]
+          variableNames: ["authoredStyleDefinitions"]
         },
         localStylePaletteName: {
           dependencyType: "stateVariable",
@@ -41621,7 +41751,7 @@ function returnStyleDefinitionStateVariables() {
           dependencyValues.localStylePaletteName
         );
       } else if (dependencyValues.ancestorWithStyle) {
-        startingStateVariableDefinitions = dependencyValues.ancestorWithStyle.stateValues.styleDefinitions;
+        startingStateVariableDefinitions = dependencyValues.ancestorWithStyle.stateValues.authoredStyleDefinitions;
       }
       if (!startingStateVariableDefinitions) {
         startingStateVariableDefinitions = returnDefaultStyleDefinitions();
@@ -41681,11 +41811,44 @@ function returnStyleDefinitionStateVariables() {
         styleDefinitions
       );
       return {
-        setValue: { styleDefinitions },
+        setValue: { authoredStyleDefinitions: styleDefinitions },
         sendDiagnostics: diagnostics
       };
     }
   };
+  stateVariableDefinitions.styleDefinitions = {
+    returnDependencies: () => ({
+      authoredStyleDefinitions: {
+        dependencyType: "stateVariable",
+        variableName: "authoredStyleDefinitions"
+      },
+      readerStyleOverrides: {
+        dependencyType: "stateVariable",
+        variableName: "readerStyleOverrides"
+      }
+    }),
+    definition({ dependencyValues }) {
+      if (dependencyValues.readerStyleOverrides == null) {
+        return {
+          setValue: {
+            styleDefinitions: dependencyValues.authoredStyleDefinitions
+          }
+        };
+      }
+      const styleDefinitions = {};
+      for (const styleNumber in dependencyValues.authoredStyleDefinitions) {
+        styleDefinitions[styleNumber] = Object.assign(
+          {},
+          dependencyValues.authoredStyleDefinitions[styleNumber]
+        );
+      }
+      applyReaderStyleOverrides(
+        styleDefinitions,
+        dependencyValues.readerStyleOverrides
+      );
+      return { setValue: { styleDefinitions } };
+    }
+  };
   return stateVariableDefinitions;
 }
 function returnSelectedStyleStateVariableDefinition(options = {}) {
@@ -41704,7 +41867,8 @@ function returnSelectedStyleStateVariableDefinition(options = {}) {
             dependencyType: "ancestor",
             variableNames: [
               "styleDefinitions",
-              "activeStylePaletteName"
+              "activeStylePaletteName",
+              "readerStyleOverrides"
             ]
           }
         };
@@ -41726,11 +41890,13 @@ function returnSelectedStyleStateVariableDefinition(options = {}) {
         }
         let selectedStyle = styleDefinitions[dependencyValues.styleNumber];
         if (selectedStyle === void 0) {
-          const activeStylePaletteName = dependencyValues.ancestorWithStyle?.stateValues.activeStylePaletteName;
-          if (activeStylePaletteName != null) {
+          const effectivePaletteName = resolveReaderPaletteName(
+            dependencyValues.ancestorWithStyle?.stateValues.readerStyleOverrides
+          ) ?? dependencyValues.ancestorWithStyle?.stateValues.activeStylePaletteName;
+          if (effectivePaletteName != null) {
             selectedStyle = styleDefinitions[cycleStyleNumberForPalette(
               dependencyValues.styleNumber,
-              activeStylePaletteName
+              effectivePaletteName
             )];
           }
         }
@@ -42339,7 +42505,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-BbJ5TZns-Cy0oPV4j-D0PQMZYb.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-a7S5PDuo-CKxUBTt--B9I1uHhS.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -65473,7 +65639,17 @@ class RendererInstructionBuilder {
       id: this.getRendererId(component),
       componentType: component.componentType,
       rendererType: component.rendererType,
-      actions: requestActions
+      actions: requestActions,
+      // Source range in the original DoenetML, used by hosts (e.g. the
+      // VS Code preview) to sync cursor/click position with the
+      // editor. Absent for components with no direct source origin.
+      // Note: a copy's replacement gets the copy reference's own range
+      // (e.g. `$g`'s), while descendants that already carried a
+      // position keep the original definition's range — see
+      // `assignDoenetMLRange`'s `init` flag. The viewer compensates
+      // when attributing clicks on copied content (`containsRange` in
+      // DocViewer).
+      position: component.position
     };
     this.componentsToRender[componentIdx] = {
       children: childrenToRender
@@ -67084,6 +67260,22 @@ class UpdateExecutor {
       });
       return { actionId: args.actionId };
     }
+    if (actionName === "setStyleOverrides" && componentIdx === void 0) {
+      await this.performUpdate({
+        updateInstructions: [
+          {
+            updateType: "updateValue",
+            componentIdx: this.core.documentIdx,
+            stateVariable: "readerStyleOverrides",
+            value: args.styleOverrides ?? null
+          }
+        ],
+        actionId: args.actionId,
+        doNotSave: true
+        // this isn't an interaction, so don't save doc state
+      });
+      return { actionId: args.actionId };
+    }
     let component = this.core._components[componentIdx];
     if (component && component.actions) {
       let action = component.actions[actionName];
@@ -69236,6 +69428,7 @@ class Core {
     requestedVariantIndex,
     initializeCounters = {},
     theme,
+    styleOverrides,
     prerender = false,
     stateVariableChanges: stateVariableChangesString,
     coreId,
@@ -69281,6 +69474,7 @@ class Core {
     this.numerics = new Numerics();
     this.flags = flags;
     this.theme = theme;
+    this.styleOverrides = styleOverrides;
     this.getStateVariableValue = this.getStateVariableValue.bind(this);
     this.componentInfoObjects = componentInfoObjects2;
     this.initializeCounters = initializeCounters;
@@ -69384,6 +69578,9 @@ class Core {
       serializedComponents[0].state = {};
     }
     serializedComponents[0].state.theme = this.theme;
+    if (this.styleOverrides != null) {
+      serializedComponents[0].state.readerStyleOverrides = this.styleOverrides;
+    }
     serializedComponents[0].doenetAttributes.cid = this.cid;
     this._components = [];
     this.componentIdxByStateId = {};
@@ -231920,4 +232117,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-B7dZK3j_.js.map
+//# sourceMappingURL=index-L-CvJFQy.js.map