@riverbankcms/sdk 0.76.0 → 0.77.0

package/dist/{chunk-TW2Y4RR5.mjs → chunk-GSQX43EZ.mjs}

@@ -1,6 +1,6 @@
 "use client";
-import { compileSiteThemeFromSelections, footerLookCatalog, headerLookCatalog, footerLookRejectionReasonLabel, headerLookRejectionReasonLabel, writePlanForLookCustomizationCommand, siteStyleIdFromTheme, getCuratedSiteStyle } from './chunk-LYI7TEMH.mjs';
-import { createContext, useState, useRef, useCallback, useEffect, useMemo, useContext } from 'react';
+import { assertNever2, deriveNearestCompatibleHeaderStyle, findLegacyHeaderLookIdForSelection, compileSiteThemeFromSelections, footerLookCatalog, footerLookRejectionReasonLabel, getHeaderStyle, getHeaderLayout, writePlanForLookCustomizationCommand, headerLayoutCatalog, headerStyleCatalog, getCompatibleHeaderStyleIds, siteStyleIdFromTheme, getCuratedSiteStyle } from './chunk-WLQBJN2Z.mjs';
+import { createContext, useState, useCallback, useMemo, useContext, useRef, useEffect } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
 // ../preview-next/src/client/preview/previewChromeSurfacePolicy.ts
@@ -374,7 +374,6 @@ function isDebugEnabled() {
 }
 function PreviewThemeOverlayProvider({ baseTheme, children }) {
   const [overlay, setOverlay] = useState(NO_THEME_OVERLAY);
-  const previousBaseThemeRef = useRef(null);
   const overlayOps = overlay.kind === "patch" ? [...overlay.ops] : null;
   const overlayOpsSource = overlay.kind === "patch" ? overlay.source : null;
   const overrideTheme = overlay.kind === "theme" ? overlay.theme : null;
@@ -421,12 +420,6 @@ function PreviewThemeOverlayProvider({ baseTheme, children }) {
       return NO_THEME_OVERLAY;
     });
   }, []);
-  useEffect(() => {
-    if (previousBaseThemeRef.current && previousBaseThemeRef.current !== baseTheme) {
-      setOverlay(NO_THEME_OVERLAY);
-    }
-    previousBaseThemeRef.current = baseTheme;
-  }, [baseTheme]);
   const effectiveTheme = useMemo(() => {
     if (overlay.kind === "theme") return overlay.theme;
     if (overlay.kind !== "patch" || overlay.ops.length === 0) return baseTheme;
@@ -478,6 +471,200 @@ function usePreviewThemeOverlay() {
   return ctx;
 }
 
+// ../preview-next/src/client/preview/previewDesignCoordinator.ts
+var NO_PREVIEW_DESIGN_STATE = { kind: "idle" };
+function transitionPreviewDesignState(state, command) {
+  switch (command.kind) {
+    case "preview-theme-patch":
+      return acceptPreview(state, {
+        kind: "active",
+        owner: command.producer,
+        surface: "theme-json-patch",
+        apply: "idle"
+      }, {
+        kind: "set-patch",
+        source: command.producer,
+        ops: command.ops
+      });
+    case "preview-theme":
+      return acceptPreview(state, {
+        kind: "active",
+        owner: command.producer,
+        surface: command.sourcePlan,
+        apply: "idle"
+      }, {
+        kind: "set-theme",
+        source: command.producer,
+        theme: command.theme
+      });
+    case "clear-preview":
+      if (state.kind === "idle") {
+        return ignored(state, "no-active-preview");
+      }
+      if (state.owner !== command.producer) {
+        return ignored(state, "producer-does-not-own-preview");
+      }
+      return accepted(NO_PREVIEW_DESIGN_STATE, { kind: "clear" });
+    case "base-theme-changed":
+      if (state.kind === "idle") {
+        return accepted(state, { kind: "none" });
+      }
+      return accepted(NO_PREVIEW_DESIGN_STATE, { kind: "clear" });
+    case "apply-started":
+      if (state.kind === "idle") {
+        return ignored(state, "no-active-preview");
+      }
+      if (state.owner !== command.producer) {
+        return ignored(state, "producer-does-not-own-preview");
+      }
+      return accepted({ ...state, apply: "pending" }, { kind: "none" });
+    case "apply-succeeded":
+      if (state.kind === "idle") {
+        return ignored(state, "apply-event-for-displaced-preview");
+      }
+      if (state.owner !== command.producer) {
+        return ignored(state, "apply-event-for-displaced-preview");
+      }
+      return accepted(NO_PREVIEW_DESIGN_STATE, { kind: "clear" });
+    case "apply-failed":
+      if (state.kind === "idle") {
+        return ignored(state, "apply-event-for-displaced-preview");
+      }
+      if (state.owner !== command.producer) {
+        return ignored(state, "apply-event-for-displaced-preview");
+      }
+      return accepted({ ...state, apply: "idle" }, { kind: "none" });
+    default:
+      return assertNever2(command, "Unhandled preview design command");
+  }
+}
+function acceptPreview(current, next, effect) {
+  return accepted(next, effect);
+}
+function accepted(state, effect) {
+  return {
+    kind: "accepted",
+    state,
+    effect
+  };
+}
+function ignored(state, reason) {
+  return {
+    kind: "ignored",
+    state,
+    reason
+  };
+}
+var PreviewDesignCoordinatorContext = createContext(null);
+function PreviewDesignCoordinatorProvider({ children }) {
+  const themeOverlay = usePreviewThemeOverlay();
+  const {
+    baseTheme,
+    clearOverlay,
+    overlay,
+    setOverlayOps,
+    setOverrideTheme
+  } = themeOverlay;
+  const [state, setState] = useState(NO_PREVIEW_DESIGN_STATE);
+  const stateRef = useRef(state);
+  const previousBaseThemeRef = useRef(null);
+  useEffect(() => {
+    stateRef.current = state;
+  }, [state]);
+  const dispatch = useCallback(
+    (command) => {
+      const transition = transitionPreviewDesignState(stateRef.current, command);
+      if (transition.kind === "accepted") {
+        stateRef.current = transition.state;
+        setState(transition.state);
+        switch (transition.effect.kind) {
+          case "none":
+            break;
+          case "clear":
+            clearOverlay();
+            break;
+          case "set-patch":
+            setOverlayOps([...transition.effect.ops], {
+              source: transition.effect.source
+            });
+            break;
+          case "set-theme":
+            setOverrideTheme(transition.effect.theme, {
+              source: transition.effect.source
+            });
+            break;
+          default:
+            assertNever2(transition.effect, "Unhandled preview design overlay effect");
+        }
+      }
+      return transition;
+    },
+    [clearOverlay, setOverlayOps, setOverrideTheme]
+  );
+  useEffect(() => {
+    if (previousBaseThemeRef.current && previousBaseThemeRef.current !== baseTheme) {
+      dispatch({ kind: "base-theme-changed" });
+    }
+    previousBaseThemeRef.current = baseTheme;
+  }, [baseTheme, dispatch]);
+  const previewTheme = useCallback(
+    (producer, theme, sourcePlan) => dispatch({ kind: "preview-theme", producer, theme, sourcePlan }),
+    [dispatch]
+  );
+  const previewThemePatch = useCallback(
+    (producer, ops) => dispatch({ kind: "preview-theme-patch", producer, ops }),
+    [dispatch]
+  );
+  const clearPreview = useCallback(
+    (producer) => dispatch({ kind: "clear-preview", producer }),
+    [dispatch]
+  );
+  const applyStarted = useCallback(
+    (producer) => dispatch({ kind: "apply-started", producer }),
+    [dispatch]
+  );
+  const applySucceeded = useCallback(
+    (producer) => dispatch({ kind: "apply-succeeded", producer }),
+    [dispatch]
+  );
+  const applyFailed = useCallback(
+    (producer) => dispatch({ kind: "apply-failed", producer }),
+    [dispatch]
+  );
+  const value = useMemo(
+    () => ({
+      state,
+      overlay,
+      dispatch,
+      previewTheme,
+      previewThemePatch,
+      clearPreview,
+      applyStarted,
+      applySucceeded,
+      applyFailed
+    }),
+    [
+      applyFailed,
+      applyStarted,
+      applySucceeded,
+      clearPreview,
+      dispatch,
+      previewTheme,
+      previewThemePatch,
+      state,
+      overlay
+    ]
+  );
+  return /* @__PURE__ */ jsx(PreviewDesignCoordinatorContext.Provider, { value, children });
+}
+function usePreviewDesignCoordinator() {
+  const ctx = useContext(PreviewDesignCoordinatorContext);
+  if (!ctx) {
+    throw new Error("usePreviewDesignCoordinator must be used within PreviewDesignCoordinatorProvider");
+  }
+  return ctx;
+}
+
 // ../preview-next/src/client/blocks/runOptimisticCustomizeAction.ts
 function createOptimisticActionRunner() {
   let latest = 0;
@@ -537,17 +724,55 @@ function previewButtonPersonality(state, buttonPersonalityId) {
     saveStatus: { kind: "idle" }
   };
 }
-function previewHeaderLook(state, headerLookId) {
+function previewHeaderLayout(state, headerLayoutId) {
+  const headerStyleId = deriveNearestCompatibleHeaderStyle(
+    state.previewed.headerStyleId,
+    headerLayoutId
+  );
+  return previewHeaderSelection(state, { headerLayoutId, headerStyleId });
+}
+function previewHeaderStyle(state, headerStyleId) {
+  return previewHeaderSelection(state, {
+    headerLayoutId: state.previewed.headerLayoutId,
+    headerStyleId
+  });
+}
+function previewFooterLook(state, footerLookId) {
   return {
     ...state,
-    previewed: { ...state.previewed, headerLookId },
+    previewed: { ...state.previewed, footerLookId },
     saveStatus: { kind: "idle" }
   };
 }
-function previewFooterLook(state, footerLookId) {
+function previewTypographyPreset(state, typographyPresetId) {
   return {
     ...state,
-    previewed: { ...state.previewed, footerLookId },
+    previewed: { ...state.previewed, typographyPresetId },
+    saveStatus: { kind: "idle" }
+  };
+}
+function setTypographyBodyFontOverride(state, typographyBodyFontOverride) {
+  return {
+    ...state,
+    previewed: { ...state.previewed, typographyBodyFontOverride },
+    saveStatus: { kind: "idle" }
+  };
+}
+function setTypographyHeadingFontOverride(state, typographyHeadingFontOverride) {
+  return {
+    ...state,
+    previewed: { ...state.previewed, typographyHeadingFontOverride },
+    saveStatus: { kind: "idle" }
+  };
+}
+function clearTypographyFontOverrides(state) {
+  return {
+    ...state,
+    previewed: {
+      ...state.previewed,
+      typographyBodyFontOverride: null,
+      typographyHeadingFontOverride: null
+    },
     saveStatus: { kind: "idle" }
   };
 }
@@ -573,7 +798,13 @@ function applyResolvedSelections(state, input) {
     ...paletteScoped,
     previewed: {
       ...paletteScoped.previewed,
-      buttonPersonalityId: input.resolved.buttonPersonalityId
+      buttonPersonalityId: input.resolved.buttonPersonalityId,
+      headerLayoutId: input.resolved.headerLayoutId,
+      headerStyleId: input.resolved.headerStyleId,
+      headerLookId: input.resolved.headerLookId,
+      typographyPresetId: input.resolved.typographyPresetId,
+      typographyBodyFontOverride: input.resolved.typographyBodyFontOverride,
+      typographyHeadingFontOverride: input.resolved.typographyHeadingFontOverride
     },
     warnings: input.warnings
   };
@@ -672,6 +903,26 @@ function movePreviewToPaletteVariant(state, paletteVariantId) {
     saveStatus: { kind: "idle" }
   };
 }
+function previewHeaderSelection(state, selection) {
+  const headerStyleId = deriveNearestCompatibleHeaderStyle(
+    selection.headerStyleId,
+    selection.headerLayoutId
+  );
+  const headerLookId = findLegacyHeaderLookIdForSelection({
+    layoutId: selection.headerLayoutId,
+    styleId: headerStyleId
+  });
+  return {
+    ...state,
+    previewed: {
+      ...state.previewed,
+      headerLayoutId: selection.headerLayoutId,
+      headerStyleId,
+      headerLookId
+    },
+    saveStatus: { kind: "idle" }
+  };
+}
 function withPaletteOverrideDraft(drafts, paletteVariantId, paletteOverrides) {
   const next = { ...drafts };
   if (paletteOverrides === null) {
@@ -692,7 +943,7 @@ function appendPaletteOverrideScopeNotice(notices, input) {
   return [...notices, { kind }];
 }
 function selectionSnapshotsEqual(a, b) {
-  return a.siteStyleId === b.siteStyleId && a.selectionVersion === b.selectionVersion && a.selectionUpdatedAt === b.selectionUpdatedAt && a.headerLookId === b.headerLookId && a.footerLookId === b.footerLookId && a.buttonPersonalityId === b.buttonPersonalityId && a.paletteVariantId === b.paletteVariantId && paletteOverridesEqual(a.paletteOverrides, b.paletteOverrides);
+  return a.siteStyleId === b.siteStyleId && a.selectionVersion === b.selectionVersion && a.selectionUpdatedAt === b.selectionUpdatedAt && a.headerLayoutId === b.headerLayoutId && a.headerStyleId === b.headerStyleId && a.headerLookId === b.headerLookId && a.footerLookId === b.footerLookId && a.buttonPersonalityId === b.buttonPersonalityId && a.paletteVariantId === b.paletteVariantId && a.typographyPresetId === b.typographyPresetId && a.typographyBodyFontOverride === b.typographyBodyFontOverride && a.typographyHeadingFontOverride === b.typographyHeadingFontOverride && paletteOverridesEqual(a.paletteOverrides, b.paletteOverrides);
 }
 function paletteOverridesEqual(a, b) {
   if (a === b) return true;
@@ -711,41 +962,40 @@ function buildSiteChromeLookModels(input) {
     buttonPersonalityId: selection.buttonPersonalityId,
     paletteVariantId: selection.paletteVariantId,
     paletteOverrides: selection.paletteOverrides,
+    headerLayoutId: selection.headerLayoutId,
+    headerStyleId: selection.headerStyleId,
     headerLookId: selection.headerLookId,
     footerLookId: selection.footerLookId,
     headerSelectionContext: input.headerSelectionContext,
     footerSelectionContext: input.footerSelectionContext
   };
   const current = compileSiteThemeFromSelections(common);
+  const renderedHeaderLayoutId = current.resolvedSelections.headerLayoutId;
+  const renderedHeaderStyleId = current.resolvedSelections.headerStyleId;
   return {
-    header: {
-      renderedLookId: current.resolvedSelections.headerLookId,
-      options: [
-        {
-          id: null,
-          label: "Site style default",
-          description: "Use the header chosen for this site style.",
+    headerLayout: {
+      renderedLayoutId: renderedHeaderLayoutId,
+      options: orderedHeaderLayoutIds(input.siteStyle).map((layoutId) => {
+        const layout = getHeaderLayout(layoutId);
+        return {
+          id: layoutId,
+          label: layout?.label ?? layoutId,
+          description: layout?.description,
           available: true
-        },
-        ...headerLookCatalog.map((look) => {
-          const result = compileSiteThemeFromSelections({
-            ...common,
-            headerLookId: look.id
-          });
-          const rejected = result.headerSelection.rejected.find((item) => item.lookId === look.id);
-          return {
-            id: look.id,
-            label: look.label,
-            description: rejected ? rejected.reasons.map(headerLookRejectionReasonLabel).join(" ") : void 0,
-            available: !rejected
-          };
-        })
-      ],
-      diagnostics: diagnosticsForRequestedHeaderSelection(
-        selection.headerLookId,
-        current.resolvedSelections.headerLookId,
-        current.headerSelection.rejected
-      )
+        };
+      })
+    },
+    headerStyle: {
+      renderedStyleId: renderedHeaderStyleId,
+      options: orderedHeaderStyleIds(input.siteStyle, selection.headerLayoutId).map((styleId) => {
+        const style = getHeaderStyle(styleId);
+        return {
+          id: styleId,
+          label: style?.label ?? styleId,
+          description: style?.description,
+          available: true
+        };
+      })
     },
     footer: {
       renderedLookId: current.resolvedSelections.footerLookId,
@@ -791,10 +1041,14 @@ function cycleableSiteChromeOptions(options) {
 }
 function planSiteChromeLookSelection(command) {
   if (command.surface === "header") {
-    const lookCommand2 = command.lookId ? {
+    const headerLookId = findLegacyHeaderLookIdForSelection({
+      layoutId: command.layoutId,
+      styleId: command.styleId
+    });
+    const lookCommand2 = headerLookId ? {
       kind: "select",
       surface: { kind: "site-header" },
-      lookId: command.lookId
+      lookId: headerLookId
     } : {
       kind: "clear",
       surface: { kind: "site-header" }
@@ -802,7 +1056,11 @@ function planSiteChromeLookSelection(command) {
     return {
       kind: "header",
       writePlan: writePlanForLookCustomizationCommand(lookCommand2),
-      next: { headerLookId: command.lookId }
+      next: {
+        headerLayoutId: command.layoutId,
+        headerStyleId: command.styleId,
+        headerLookId
+      }
     };
   }
   const lookCommand = command.lookId ? {
@@ -819,10 +1077,33 @@ function planSiteChromeLookSelection(command) {
     next: { footerLookId: command.lookId }
   };
 }
-function diagnosticsForRequestedHeaderSelection(requestedLookId, renderedLookId, rejected) {
-  if (!requestedLookId || requestedLookId === renderedLookId) return [];
-  const rejectedRequest = rejected.find((item) => item.lookId === requestedLookId);
-  return rejectedRequest?.reasons.map(headerLookRejectionReasonLabel) ?? [];
+function orderedHeaderLayoutIds(siteStyle) {
+  return orderUnique(
+    siteStyle.recommendedHeaderLayoutChoices.map((choice) => choice.id),
+    headerLayoutCatalog.map((layout) => layout.id)
+  );
+}
+function orderedHeaderStyleIds(siteStyle, layoutId) {
+  const curated = headerStyleChoicesForLayout(
+    siteStyle.recommendedHeaderStyleChoicesByLayout,
+    layoutId
+  ).map((choice) => choice.id);
+  return orderUnique(curated, getCompatibleHeaderStyleIds(layoutId), headerStyleCatalog.map((style) => style.id));
+}
+function headerStyleChoicesForLayout(choicesByLayout, layoutId) {
+  return choicesByLayout[layoutId] ?? [];
+}
+function orderUnique(...groups) {
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const group of groups) {
+    for (const id of group) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+      ordered.push(id);
+    }
+  }
+  return ordered;
 }
 function diagnosticsForRequestedFooterSelection(requestedLookId, renderedLookId, rejected) {
   if (!requestedLookId || requestedLookId === renderedLookId) return [];
@@ -830,6 +1111,23 @@ function diagnosticsForRequestedFooterSelection(requestedLookId, renderedLookId,
   return rejectedRequest?.reasons.map(footerLookRejectionReasonLabel) ?? [];
 }
 
+// ../preview-next/src/client/preview/typographySelectionInput.ts
+function typographySelectionInputForSnapshot(snapshot, theme) {
+  if (snapshot.typographyPresetId === null && theme?.typography) {
+    return {
+      typographySelection: {
+        kind: "custom",
+        typography: theme.typography
+      }
+    };
+  }
+  return {
+    typographyPresetId: snapshot.typographyPresetId,
+    typographyBodyFontOverride: snapshot.typographyBodyFontOverride,
+    typographyHeadingFontOverride: snapshot.typographyHeadingFontOverride
+  };
+}
+
 // ../preview-next/src/client/preview/styleConfiguratorSnapshot.ts
 function resolveStyleConfiguratorInitialSnapshot(input) {
   const themeSiteStyleId = siteStyleIdFromTheme(input.theme);
@@ -841,6 +1139,9 @@ function resolveStyleConfiguratorInitialSnapshot(input) {
     buttonPersonalityId: input.initialSelections.buttonPersonalityId,
     paletteVariantId: input.initialSelections.paletteVariantId,
     paletteOverrides: input.initialSelections.paletteOverrides,
+    headerLayoutId: input.initialSelections.headerLayoutId ?? null,
+    headerStyleId: input.initialSelections.headerStyleId ?? null,
+    ...typographySelectionInputForSnapshot(input.initialSelections, input.theme),
     headerLookId: input.initialSelections.headerLookId ?? null,
     footerLookId: input.initialSelections.footerLookId ?? null,
     headerSelectionContext: input.headerSelectionContext,
@@ -851,12 +1152,43 @@ function resolveStyleConfiguratorInitialSnapshot(input) {
     siteStyleId: siteStyle.id,
     selectionVersion: input.initialSelections.selectionVersion ?? 0,
     selectionUpdatedAt: input.initialSelections.selectionUpdatedAt ?? null,
+    headerLayoutId: compiled.resolvedSelections.headerLayoutId,
+    headerStyleId: compiled.resolvedSelections.headerStyleId,
     headerLookId: compiled.requestedSelections.headerLookId,
     footerLookId: compiled.requestedSelections.footerLookId,
     buttonPersonalityId: compiled.resolvedSelections.buttonPersonalityId,
     paletteVariantId: compiled.resolvedSelections.paletteVariantId,
-    paletteOverrides: paletteChanged ? null : input.initialSelections.paletteOverrides
+    paletteOverrides: paletteChanged ? null : input.initialSelections.paletteOverrides,
+    typographyPresetId: compiled.resolvedSelections.typographyPresetId,
+    typographyBodyFontOverride: compiled.resolvedSelections.typographyBodyFontOverride,
+    typographyHeadingFontOverride: compiled.resolvedSelections.typographyHeadingFontOverride
+  };
+}
+
+// ../preview-next/src/client/preview/siteStylePreviewPlanner.ts
+function planSiteStylePreviewChange(input) {
+  const compiled = compileSiteThemeFromSelections({
+    siteStyle: input.siteStyle,
+    buttonPersonalityId: input.selection.buttonPersonalityId,
+    paletteVariantId: input.selection.paletteVariantId,
+    paletteOverrides: input.selection.paletteOverrides,
+    ...typographySelectionInputForSnapshot(input.selection, input.baseTheme),
+    headerLayoutId: input.selection.headerLayoutId,
+    headerStyleId: input.selection.headerStyleId,
+    headerLookId: input.selection.headerLookId,
+    footerLookId: input.selection.footerLookId,
+    headerSelectionContext: input.headerSelectionContext,
+    footerSelectionContext: input.footerSelectionContext
+  });
+  return {
+    themeOverlay: compiled.theme,
+    resolvedSelections: compiled.resolvedSelections,
+    chromeSelection: {
+      headerLookId: input.selection.headerLookId,
+      footerLookId: input.selection.footerLookId
+    },
+    warnings: compiled.warnings
   };
 }
 
-export { PreviewThemeOverlayProvider, applyResolvedSelections, buildPreviewDashboardSetupUrl, buildSiteChromeLookModels, canApplySiteStyle, canInspectSiteStyle, cancelPreview, createOptimisticActionRunner, createStyleConfiguratorState, cycleSiteChromeLookId, cycleableSiteChromeOptions, dismissNotices, dismissWarnings, isPreviewingChange, markApplyFailed, markApplySaved, markApplySaving, openRow, planSiteChromeLookSelection, previewButtonPersonality, previewFooterLook, previewHeaderLook, previewPaletteVariant, previewSiteStyle, resolvePreviewDashboardSetupHandoff, resolvePreviewEditorGuidanceModel, resolvePreviewSetupBannerModel, resolvePreviewSidebarChromeModel, resolveSiteStyleAccess, resolveStyleConfiguratorInitialSnapshot, sanitizeDashboardPath, setPaletteOverrides, syncStyleConfiguratorState, toggleRow, usePreviewThemeOverlay };
+export { PreviewDesignCoordinatorProvider, PreviewThemeOverlayProvider, applyResolvedSelections, buildPreviewDashboardSetupUrl, buildSiteChromeLookModels, canApplySiteStyle, canInspectSiteStyle, cancelPreview, clearTypographyFontOverrides, createOptimisticActionRunner, createStyleConfiguratorState, cycleSiteChromeLookId, cycleableSiteChromeOptions, dismissNotices, dismissWarnings, isPreviewingChange, markApplyFailed, markApplySaved, markApplySaving, openRow, planSiteChromeLookSelection, planSiteStylePreviewChange, previewButtonPersonality, previewFooterLook, previewHeaderLayout, previewHeaderStyle, previewPaletteVariant, previewSiteStyle, previewTypographyPreset, resolvePreviewDashboardSetupHandoff, resolvePreviewEditorGuidanceModel, resolvePreviewSetupBannerModel, resolvePreviewSidebarChromeModel, resolveSiteStyleAccess, resolveStyleConfiguratorInitialSnapshot, sanitizeDashboardPath, setPaletteOverrides, setTypographyBodyFontOverride, setTypographyHeadingFontOverride, syncStyleConfiguratorState, toggleRow, usePreviewDesignCoordinator, usePreviewThemeOverlay };