@riverbankcms/sdk 0.78.2 → 0.80.0

package/dist/{chunk-6HYXHRAI.mjs → chunk-HTB4BMKD.mjs}

@@ -1,6 +1,6 @@
 "use client";
-import { assertNever2, useOptionalEditorUiStoreInstance, getPageDesignEditorState, PAGE_DESIGN_EDITOR_STATE_FETCH_ERROR_MESSAGE, useDebouncedLatestSave, applyPageDesignEditorAction, unsafeAsEditorBlockId, unsafeAsEditorBlockValues, resolvePreviewSidebarTab, systemCustomizeFacetDefinitionForBlock, systemCustomizeFacetRollbackContentPatch, systemCustomizeFacetApplyContentPatch, createHistoryState, redoHistory, undoHistory, pushHistoryEntry, canRedoHistory, canUndoHistory, planPageDesignLayoutLookCompatibility } from './chunk-MCRQMPET.mjs';
-import { ApiRequestError, resolveSurfaceDocumentAttributes, SURFACE_DOCUMENT_DATA_ATTRIBUTE, SURFACE_IDS } from './chunk-CR5HKAGU.mjs';
+import { assertNever2, useOptionalEditorUiStoreInstance, getPageDesignEditorState, PAGE_DESIGN_EDITOR_STATE_FETCH_ERROR_MESSAGE, unwrapResponse, useDebouncedLatestSave, applyPageDesignEditorAction, AMBIENT_BACKGROUND_ROLES, resolvePreviewSidebarTab, applyBackgroundOverrideContentPatch, systemCustomizeFacetDefinitionForBlock, systemCustomizeFacetRollbackContentPatch, systemCustomizeFacetApplyContentPatch, unsafeAsEditorBlockId, createHistoryState, redoHistory, undoHistory, pushHistoryEntry, canRedoHistory, canUndoHistory, backgroundOverrideEquals, planPageDesignLayoutLookCompatibility, unsafeAsEditorBlockValues } from './chunk-GYXKAUFV.mjs';
+import { ApiRequestError, resolveSurfaceDocumentAttributes, SURFACE_DOCUMENT_DATA_ATTRIBUTE, SURFACE_IDS } from './chunk-BBLZSQEY.mjs';
 import { createContext, useState, useRef, useEffect, useMemo, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
@@ -86,6 +86,21 @@ function previewCustomizeHistoryEntryFromAction(editorModel, action) {
         toValue: action.value
       };
     }
+    case "set-background": {
+      const block = editorModel.blocks.find(
+        (candidate) => candidate.blockId === action.blockId
+      ) ?? null;
+      if (!block) return null;
+      if (backgroundOverrideEquals(action.fromOverride, action.override)) {
+        return null;
+      }
+      return {
+        kind: "background",
+        blockId: action.blockId,
+        fromOverride: action.fromOverride,
+        toOverride: action.override
+      };
+    }
     case "set-boundary":
     case "reset-boundary": {
       const boundary = editorModel.boundaries.find(
@@ -146,6 +161,17 @@ function previewCustomizeActionForEntryValue(entry, valueKey, editorModel) {
         baseContentId: contentRevisionIdForBlock(editorModel, entry.blockId)
       };
     }
+    case "background": {
+      const override = valueKey === "from" ? entry.fromOverride : entry.toOverride;
+      const fromOverride = valueKey === "from" ? entry.toOverride : entry.fromOverride;
+      return {
+        kind: "set-background",
+        blockId: entry.blockId,
+        override,
+        fromOverride,
+        baseContentId: contentRevisionIdForBlock(editorModel, entry.blockId)
+      };
+    }
     case "boundary": {
       const boundaryOptionId = valueKey === "from" ? entry.fromBoundaryOptionId : entry.toBoundaryOptionId;
       return boundaryOptionId ? {
@@ -182,6 +208,7 @@ function previewCustomizeHistoryEntryStillApplies(entry, editorModel) {
     case "layout":
     case "look":
     case "block-facet":
+    case "background":
       return editorModel.blocks.some((block) => block.blockId === entry.blockId);
     case "boundary":
       return editorModel.boundaries.some(
@@ -201,6 +228,8 @@ function previewCustomizeHistoryEntryEquals(left, right) {
       return right.kind === "look" && left.blockId === right.blockId && left.fromAppearancePresetId === right.fromAppearancePresetId && left.toAppearancePresetId === right.toAppearancePresetId;
     case "block-facet":
       return right.kind === "block-facet" && left.blockId === right.blockId && left.facetId === right.facetId && left.fromValue === right.fromValue && left.toValue === right.toValue;
+    case "background":
+      return right.kind === "background" && left.blockId === right.blockId && backgroundOverrideEquals(left.fromOverride, right.fromOverride) && backgroundOverrideEquals(left.toOverride, right.toOverride);
     case "boundary":
       return right.kind === "boundary" && left.boundaryId === right.boundaryId && left.previousBlockId === right.previousBlockId && left.nextBlockId === right.nextBlockId && left.fromBoundaryOptionId === right.fromBoundaryOptionId && left.toBoundaryOptionId === right.toBoundaryOptionId;
     default:
@@ -558,6 +587,8 @@ function sameCustomizeTarget(left, right) {
       return right.kind === "set-look" && left.blockId === right.blockId;
     case "set-block-facet":
       return right.kind === "set-block-facet" && left.blockId === right.blockId && left.facetId === right.facetId;
+    case "set-background":
+      return right.kind === "set-background" && left.blockId === right.blockId;
     case "set-boundary":
     case "reset-boundary":
       return (right.kind === "set-boundary" || right.kind === "reset-boundary") && left.previousBlockId === right.previousBlockId && left.nextBlockId === right.nextBlockId;
@@ -615,6 +646,7 @@ function applyPreviewCustomizeActionToLoadedState(state, action) {
         }
       };
     case "set-block-facet":
+    case "set-background":
       return state;
     case "set-boundary":
     case "reset-boundary":
@@ -695,6 +727,7 @@ function classifyPreviewCustomizeActionDomain(action) {
   switch (action.kind) {
     case "set-layout":
     case "set-block-facet":
+    case "set-background":
       return { kind: "block-content-write" };
     case "set-look":
     case "set-boundary":
@@ -713,6 +746,7 @@ function derivePreviewCustomizeRuntimePatch(input) {
     case "set-layout":
       return {
         blockId: action.blockId,
+        ownedRuntimeFieldPaths: [],
         previousContent,
         nextContent: contentWithLayoutVariant(
           previousContent,
@@ -732,6 +766,7 @@ function derivePreviewCustomizeRuntimePatch(input) {
       if (!definition) return null;
       return {
         blockId: action.blockId,
+        ownedRuntimeFieldPaths: [],
         previousContent,
         nextContent: systemCustomizeFacetApplyContentPatch(
           definition,
@@ -745,6 +780,17 @@ function derivePreviewCustomizeRuntimePatch(input) {
         )
       };
     }
+    case "set-background":
+      return {
+        blockId: action.blockId,
+        ownedRuntimeFieldPaths: ["_sectionStyles.background"],
+        previousContent,
+        nextContent: applyBackgroundOverrideContentPatch(
+          previousContent,
+          action.override
+        ),
+        rollback: (currentContent) => contentWithPreviousBackground(currentContent, previousContent)
+      };
     case "set-look":
       return null;
     case "set-boundary":
@@ -767,11 +813,114 @@ function contentWithPreviousLayoutVariant(currentContent, previousContent) {
   }
   return nextContent;
 }
+function contentWithPreviousBackground(currentContent, previousContent) {
+  const previousSectionStyles = isRecord(previousContent._sectionStyles) ? previousContent._sectionStyles : {};
+  const currentSectionStyles = isRecord(currentContent._sectionStyles) ? currentContent._sectionStyles : {};
+  const nextSectionStyles = { ...currentSectionStyles };
+  if (Object.prototype.hasOwnProperty.call(previousSectionStyles, "background")) {
+    nextSectionStyles.background = previousSectionStyles.background;
+  } else {
+    delete nextSectionStyles.background;
+  }
+  if (Object.keys(nextSectionStyles).length > 0) {
+    return {
+      ...currentContent,
+      _sectionStyles: nextSectionStyles
+    };
+  }
+  const nextContent = { ...currentContent };
+  delete nextContent._sectionStyles;
+  return nextContent;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// ../preview-next/src/client/preview/previewCustomizeEditorDraftPatch.ts
+function applyPreviewCustomizeDraftPatch(uiStore, patch, editorModel) {
+  return replaceLocalBlockContentWithoutHistory({
+    uiStore,
+    targetBlockId: patch.blockId,
+    nextContent: patch.nextContent,
+    previousContent: patch.previousContent,
+    editorModel
+  });
+}
+function rollbackPreviewCustomizeDraftPatch(uiStore, patch) {
+  if (!patch) return { kind: "missing-current-content" };
+  const currentContent = currentLocalBlockContent(uiStore, patch.blockId);
+  if (!currentContent) return { kind: "missing-current-content" };
+  return replaceLocalBlockContentWithoutHistory({
+    uiStore,
+    targetBlockId: patch.blockId,
+    nextContent: patch.rollback(currentContent),
+    previousContent: patch.previousContent,
+    editorModel: null
+  });
+}
+function currentLocalBlockContent(uiStore, targetBlockId) {
+  const current = uiStore.getState().drafts.getCurrentValues(unsafeAsEditorBlockId(targetBlockId));
+  return isRecord2(current) ? current : null;
+}
+function replaceLocalBlockContentWithoutHistory(input) {
+  const editorBlockId = unsafeAsEditorBlockId(input.targetBlockId);
+  const history = input.uiStore.getState().history;
+  const snapshot = history.getState().present;
+  const draft = snapshot.drafts[editorBlockId];
+  const nextDraft = draft ? applyDraftContentPatch(draft, input.nextContent) : localRuntimeDraftForBlock({
+    editorBlockId,
+    targetBlockId: input.targetBlockId,
+    editorModel: input.editorModel,
+    previousContent: input.previousContent,
+    nextContent: input.nextContent
+  });
+  if (!nextDraft) return { kind: "missing-block-model" };
+  history.restorePresent({
+    ...snapshot,
+    drafts: {
+      ...snapshot.drafts,
+      [editorBlockId]: nextDraft
+    }
+  });
+  return { kind: "applied" };
+}
+function applyDraftContentPatch(draft, nextContent) {
+  return {
+    ...draft,
+    version: draft.version + 1,
+    current: unsafeAsEditorBlockValues(nextContent)
+  };
+}
+function localRuntimeDraftForBlock(input) {
+  const block = input.editorModel?.blocks.find(
+    (candidate) => candidate.blockId === input.targetBlockId
+  ) ?? null;
+  if (!block) return null;
+  return {
+    id: input.editorBlockId,
+    version: 1,
+    baseline: unsafeAsEditorBlockValues(input.previousContent),
+    current: unsafeAsEditorBlockValues(input.nextContent),
+    syncState: { kind: "pending" },
+    meta: {
+      kind: block.blockKind,
+      purpose: null,
+      orderIndex: null,
+      publishedContent: null
+    }
+  };
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 var PREVIEW_CUSTOMIZE_STALE_MESSAGE = "This page changed since that design choice. Refresh the preview, then try again.";
 var PageDesignEditorStateContext = createContext({
   state: { kind: "unsupported" },
   reload: () => {
   },
+  backgroundImagePool: [],
+  backgroundImagePoolStatus: "idle",
+  loadBackgroundImagePool: async () => [],
   applyAction: async () => skippedPreviewCustomizeOutcome("disabled"),
   undo: async () => skippedPreviewCustomizeOutcome("disabled"),
   redo: async () => skippedPreviewCustomizeOutcome("disabled"),
@@ -793,7 +942,10 @@ function PreviewPageDesignEditorStateProvider({
   const [workflowState, setWorkflowState] = useState(
     unsupportedPreviewCustomizeWorkflowState
   );
+  const [backgroundImagePool, setBackgroundImagePool] = useState([]);
+  const [backgroundImagePoolStatus, setBackgroundImagePoolStatus] = useState("idle");
   const workflowStateRef = useRef(workflowState);
+  const backgroundImagePoolRequestRef = useRef(null);
   const uiStore = useOptionalEditorUiStoreInstance();
   useEffect(() => {
     workflowStateRef.current = workflowState;
@@ -801,6 +953,9 @@ function PreviewPageDesignEditorStateProvider({
   useEffect(() => {
     if (!enabled || !pageId) {
       setWorkflowState(unsupportedPreviewCustomizeWorkflowState());
+      setBackgroundImagePool([]);
+      setBackgroundImagePoolStatus("idle");
+      backgroundImagePoolRequestRef.current = null;
       return;
     }
     let cancelled = false;
@@ -827,6 +982,52 @@ function PreviewPageDesignEditorStateProvider({
       cancelled = true;
     };
   }, [apiClient, enabled, pageId, reloadKey, siteId]);
+  const loadBackgroundImagePool = useMemo(
+    () => async () => {
+      if (!enabled || !pageId) return [];
+      if (backgroundImagePoolStatus === "loaded") return backgroundImagePool;
+      if (backgroundImagePoolRequestRef.current) {
+        return backgroundImagePoolRequestRef.current;
+      }
+      setBackgroundImagePoolStatus("loading");
+      const request = apiClient({
+        endpoint: "mediaList",
+        params: {
+          siteId,
+          fileFilter: "images",
+          limit: "48"
+        },
+        options: { cache: "no-store" }
+      }).then((response) => {
+        const result = unwrapResponse(response);
+        const nextPool = result.items.map(backgroundImagePoolItemForAsset);
+        setBackgroundImagePool(nextPool);
+        setBackgroundImagePoolStatus("loaded");
+        return nextPool;
+      }).catch((error) => {
+        setBackgroundImagePoolStatus("failed");
+        if (!(error instanceof ApiRequestError)) {
+          console.error(
+            "[preview-page-design-editor-state] Failed to load background images",
+            error
+          );
+        }
+        return [];
+      }).finally(() => {
+        backgroundImagePoolRequestRef.current = null;
+      });
+      backgroundImagePoolRequestRef.current = request;
+      return request;
+    },
+    [
+      apiClient,
+      backgroundImagePool,
+      backgroundImagePoolStatus,
+      enabled,
+      pageId,
+      siteId
+    ]
+  );
   const autosave = useDebouncedLatestSave({
     getSnapshot: () => previewCustomizePendingActions(workflowStateRef.current),
     buildPayload: (actions) => actions,
@@ -879,7 +1080,10 @@ function PreviewPageDesignEditorStateProvider({
     () => ({
       state: previewCustomizeWorkflowPageState(workflowState),
       reload: () => setReloadKey((current) => current + 1),
-      applyAction: async (action) => {
+      backgroundImagePool,
+      backgroundImagePoolStatus,
+      loadBackgroundImagePool,
+      applyAction: async (action, options) => {
         if (!enabled) return skippedPreviewCustomizeOutcome("disabled");
         if (!pageId) return skippedPreviewCustomizeOutcome("missing-page");
         const previousWorkflow = workflowState;
@@ -887,7 +1091,12 @@ function PreviewPageDesignEditorStateProvider({
         if (begin.kind === "skipped") return begin;
         const previousPageState = previewCustomizeWorkflowPageState(previousWorkflow);
         if (previousPageState.kind === "loaded" && uiStore) {
-          applyLocalRuntimePatch(uiStore, action, previousPageState.editorModel);
+          applyLocalRuntimePatch(
+            uiStore,
+            action,
+            previousPageState.editorModel,
+            options?.runtimeContent ?? null
+          );
         }
         setWorkflowState(begin.state);
         autosave.trigger();
@@ -971,10 +1180,48 @@ function PreviewPageDesignEditorStateProvider({
       isHistoryStale: previewCustomizeIsStale(workflowState),
       historyFailure: previewCustomizeFailureMessage(workflowState)
     }),
-    [apiClient, autosave, enabled, pageId, siteId, uiStore, workflowState]
+    [
+      apiClient,
+      autosave,
+      backgroundImagePool,
+      backgroundImagePoolStatus,
+      enabled,
+      loadBackgroundImagePool,
+      pageId,
+      siteId,
+      uiStore,
+      workflowState
+    ]
   );
   return /* @__PURE__ */ jsx(PageDesignEditorStateContext.Provider, { value, children });
 }
+function backgroundImagePoolItemForAsset(asset) {
+  const backgroundUse = backgroundUseForAsset(asset.fileUses ?? []);
+  return {
+    mediaId: asset.id,
+    source: backgroundUse === null ? "general-media" : backgroundUse === "selected-background" ? "previous-background" : "generated-ambient",
+    label: asset.title || asset.filename,
+    ...isAmbientBackgroundRole(backgroundUse) ? { rank: AMBIENT_BACKGROUND_ROLES.indexOf(backgroundUse) } : {}
+  };
+}
+function isAmbientBackgroundRole(value) {
+  return typeof value === "string" && AMBIENT_BACKGROUND_ROLES.includes(value);
+}
+function backgroundUseForAsset(fileUses) {
+  const ambientUse = fileUses.find(isAmbientBackgroundFileUse);
+  if (ambientUse) return ambientUse.backgroundUse;
+  const selectedUse = fileUses.find(isSelectedBackgroundFileUse);
+  return selectedUse?.backgroundUse ?? null;
+}
+function isAmbientBackgroundFileUse(value) {
+  return isBackgroundFileUse(value) && isAmbientBackgroundRole(value.backgroundUse);
+}
+function isSelectedBackgroundFileUse(value) {
+  return isBackgroundFileUse(value) && value.backgroundUse === "selected-background";
+}
+function isBackgroundFileUse(value) {
+  return value.tag === "site-background-asset";
+}
 function pageDesignEditorActionForPersistence(action) {
   if (action.kind === "reset-boundary") {
     return {
@@ -993,6 +1240,13 @@ function pageDesignEditorActionForPersistence(action) {
         value: action.value,
         baseContentId: action.baseContentId
       };
+    case "set-background":
+      return {
+        kind: "set-background",
+        blockId: action.blockId,
+        baseContentId: action.baseContentId,
+        override: action.override
+      };
     case "set-layout":
     case "set-look":
     case "set-boundary":
@@ -1009,6 +1263,7 @@ function actionWithCurrentBaseContentId(action, editorModel) {
         baseContentId: editorModel ? contentRevisionIdForBlock(editorModel, action.blockId) : null
       };
     case "set-block-facet":
+    case "set-background":
       return {
         ...action,
         baseContentId: editorModel ? contentRevisionIdForBlock(editorModel, action.blockId) : null
@@ -1036,41 +1291,28 @@ function classifyApplyActionError(error) {
 function usePreviewPageDesignEditorState() {
   return useContext(PageDesignEditorStateContext);
 }
-function applyLocalRuntimePatch(uiStore, action, editorModel) {
+function applyLocalRuntimePatch(uiStore, action, editorModel, fallbackContent = null) {
   if (classifyPreviewCustomizeActionDomain(action).kind !== "block-content-write") {
     return null;
   }
   const patch = derivePreviewCustomizeRuntimePatch({
     action,
     editorModel,
-    currentContent: currentLocalBlockContent(
-      uiStore,
-      blockIdForRuntimePatch(action)
-    )
+    currentContent: currentLocalBlockContent(uiStore, blockIdForRuntimePatch(action)) ?? fallbackContent
   });
   if (!patch) return null;
-  replaceLocalBlockContentWithoutHistory(
-    uiStore,
-    patch.blockId,
-    patch.nextContent
-  );
+  applyPreviewCustomizeDraftPatch(uiStore, patch, editorModel);
   return patch;
 }
 function rollbackLocalRuntimePatch(uiStore, patch) {
-  if (!patch) return;
-  const currentContent = currentLocalBlockContent(uiStore, patch.blockId);
-  if (!currentContent) return;
-  replaceLocalBlockContentWithoutHistory(
-    uiStore,
-    patch.blockId,
-    patch.rollback(currentContent)
-  );
+  rollbackPreviewCustomizeDraftPatch(uiStore, patch);
 }
 function blockIdForRuntimePatch(action) {
   switch (action.kind) {
     case "set-layout":
     case "set-look":
     case "set-block-facet":
+    case "set-background":
       return action.blockId;
     case "set-boundary":
     case "reset-boundary":
@@ -1079,30 +1321,6 @@ function blockIdForRuntimePatch(action) {
       return assertNever2(action, "Unhandled runtime patch action");
   }
 }
-function currentLocalBlockContent(uiStore, targetBlockId) {
-  const current = uiStore.getState().drafts.getCurrentValues(unsafeAsEditorBlockId(targetBlockId));
-  return isRecord(current) ? current : null;
-}
-function replaceLocalBlockContentWithoutHistory(uiStore, targetBlockId, nextContent) {
-  const editorBlockId = unsafeAsEditorBlockId(targetBlockId);
-  const history = uiStore.getState().history;
-  const snapshot = history.getState().present;
-  const draft = snapshot.drafts[editorBlockId];
-  if (!draft) return;
-  history.restorePresent({
-    ...snapshot,
-    drafts: {
-      ...snapshot.drafts,
-      [editorBlockId]: {
-        ...draft,
-        current: unsafeAsEditorBlockValues(nextContent)
-      }
-    }
-  });
-}
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 
 // ../preview-next/src/client/preview/previewChromeSurface.ts
 var PREVIEW_CHROME_THEME_CLASS_NAME = "builder-dashboard-chrome-theme";
@@ -1145,7 +1363,7 @@ function applyPreviewChromeSurfaceToElement(element, surface, options) {
 var STORAGE_KEY = "preview-sidebar-tab";
 var REQUEST_EVENT = "riverbank:preview-sidebar:request-open";
 function parsePreviewSidebarOpenRequestDetail(detail) {
-  const request = isRecord2(detail) ? detail : {};
+  const request = isRecord3(detail) ? detail : {};
   const tab = request.tab === "assistant" ? "assistant" : "editor";
   return {
     tab: resolvePreviewSidebarTab(tab),
@@ -1177,7 +1395,7 @@ function onPreviewSidebarOpenRequest(handler) {
   window.addEventListener(REQUEST_EVENT, listener);
   return () => window.removeEventListener(REQUEST_EVENT, listener);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 var PREVIEW_SURFACE_PARAM = "preview_surface";

package/dist/{chunk-OKMBEAXY.mjs → chunk-MPBNEVPB.mjs}

@@ -1,5 +1,5 @@
 "use client";
-import { ApiRequestError, markPreviewAuthExpired } from './chunk-CR5HKAGU.mjs';
+import { ApiRequestError, markPreviewAuthExpired } from './chunk-BBLZSQEY.mjs';
 import { createContext, useContext, useRef } from 'react';
 import { jsx } from 'react/jsx-runtime';
 import { QueryClient, MutationCache, QueryCache, QueryClientProvider } from '@tanstack/react-query';