Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
fix: keep publish progress after closing popover (#6570)
Oleg Isonen534401c66b30
diff --git a/apps/builder/app/builder/features/publish/domain-checkbox.tsx b/apps/builder/app/builder/features/publish/domain-checkbox.tsxindex 756ee15ae9..f82c445d01 100644--- a/apps/builder/app/builder/features/publish/domain-checkbox.tsx+++ b/apps/builder/app/builder/features/publish/domain-checkbox.tsx@@ -1,4 +1,5 @@import { useStore } from "@nanostores/react";+import { useEffect, useRef, useState } from "react";import {Flex,Tooltip,@@ -38,6 +39,7 @@ export const __testing__ = { isCustomDomainPublishRestricted };interface DomainCheckboxProps {defaultChecked?: boolean;+ validatedDomains?: readonly string[];domain: string;buildId: string | undefined;disabled?: boolean;@@ -48,6 +50,35 @@ export const DomainCheckbox = (props: DomainCheckboxProps) => {const { allowStagingPublish, canPublishToStagingOnly } =useStore($permissions);const project = useStore($project);+ const restoredChecked =+ props.validatedDomains?.includes(props.domain) ??+ props.defaultChecked ??+ false;+ const [selected, setSelected] = useState(restoredChecked);+ const previous = useRef({+ buildId: props.buildId,+ validatedDomains: props.validatedDomains,+ });+ const hasNewValidation =+ props.validatedDomains !== undefined &&+ previous.current.validatedDomains !== props.validatedDomains;+ const hasNewBuild = previous.current.buildId !== props.buildId;++ useEffect(() => {+ if (hasNewValidation || hasNewBuild) {+ setSelected(restoredChecked);+ }+ previous.current = {+ buildId: props.buildId,+ validatedDomains: props.validatedDomains,+ };+ }, [+ hasNewValidation,+ hasNewBuild,+ props.validatedDomains,+ props.buildId,+ restoredChecked,+ ]);if (project === undefined) {return;@@ -97,7 +128,11 @@ export const DomainCheckbox = (props: DomainCheckboxProps) => {canPublishToStagingOnly,isCustomDomain: props.isCustomDomain,});- const defaultChecked = isRestricted ? false : props.defaultChecked;+ const checked = isRestricted+ ? false+ : hasNewValidation || hasNewBuild+ ? restoredChecked+ : selected;const disabled = isRestricted ? true : props.disabled;const hideDomainCheckbox =@@ -111,7 +146,8 @@ export const DomainCheckbox = (props: DomainCheckboxProps) => {<Checkboxdisabled={disabled}key={props.buildId ?? "-"}- defaultChecked={hideDomainCheckbox || defaultChecked}+ checked={hideDomainCheckbox || checked}+ onCheckedChange={(value) => setSelected(value === true)}css={{ pointerEvents: "all" }}name={domainToPublishName}value={props.domain}diff --git a/apps/builder/app/builder/features/publish/domains.tsx b/apps/builder/app/builder/features/publish/domains.tsxindex ff0e392386..b7610b773b 100644--- a/apps/builder/app/builder/features/publish/domains.tsx+++ b/apps/builder/app/builder/features/publish/domains.tsx@@ -189,11 +189,13 @@ const DomainItem = ({projectDomain,project,refresh,+ validatedDomains,}: {initiallyOpen: boolean;projectDomain: Domain;project: Project;refresh: () => Promise<void>;+ validatedDomains?: readonly string[];}) => {const timeSinceLastUpdateMs =Date.now() - new Date(projectDomain.updatedAt).getTime();@@ -355,6 +357,7 @@ const DomainItem = ({projectDomain.latestBuildVirtual.buildId ===project.latestBuildVirtual?.buildId}+ validatedDomains={validatedDomains}domain={projectDomain.domain}disabled={domainStatus !== "VERIFIED_ACTIVE"}isCustomDomain@@ -578,6 +581,7 @@ type DomainsProps = {domains: Domain[];refresh: () => Promise<void>;project: Project;+ validatedDomains?: readonly string[];};export const Domains = ({@@ -585,6 +589,7 @@ export const Domains = ({domains,refresh,project,+ validatedDomains,}: DomainsProps) => {return (<>@@ -595,6 +600,7 @@ export const Domains = ({initiallyOpen={newDomains.has(projectDomain.domain)}refresh={refresh}project={project}+ validatedDomains={validatedDomains}/>))}</>diff --git a/apps/builder/app/builder/features/publish/publish-actions.test.tsx b/apps/builder/app/builder/features/publish/publish-actions.test.tsxindex 9fc4fbee5f..1d4fc47d28 100644--- a/apps/builder/app/builder/features/publish/publish-actions.test.tsx+++ b/apps/builder/app/builder/features/publish/publish-actions.test.tsx@@ -2,7 +2,7 @@ import { createRef, useState } from "react";import { createRoot, type Root } from "react-dom/client";import { act } from "react-dom/test-utils";import { afterEach, expect, test, vi } from "vitest";-import { TooltipProvider } from "@webstudio-is/design-system";+import { TooltipProvider, toast } from "@webstudio-is/design-system";import { PublishActions, usePublishValidationState } from "./publish-actions";let root: Root | undefined;@@ -17,6 +17,7 @@ afterEach(() => {root = undefined;container?.remove();container = undefined;+ vi.restoreAllMocks();});const render = (@@ -76,8 +77,9 @@ test("shows the successful validation state in the action", () => {test("clears the validation result when the publish popover closes", async () => {const Harness = () => {const [isOpen, setIsOpen] = useState(true);- const { validationState, update, reset } =- usePublishValidationState(isOpen);+ const { validationState, update, reset } = usePublishValidationState(+ isOpen ? "publish" : "none"+ );return (<TooltipProvider>@@ -138,6 +140,80 @@ test("clears the validation result when the publish popover closes", async () =>expect(reopenedValidate.querySelector("svg")).toBeNull();});+test.each([+ { destination: "none" as const, expectedToasts: 1 },+ { destination: "none" as const, reopen: true, expectedToasts: 0 },+ { destination: "export" as const, expectedToasts: 1 },+ { destination: "publish" as const, expectedToasts: 0 },+])(+ "reports validation success after switching to $destination (reopen: $reopen)",+ async ({ destination, reopen, expectedToasts }) => {+ const successToast = vi+ .spyOn(toast, "success")+ .mockImplementation(() => "");+ let finishValidation: () => void = () => {};+ const validation = new Promise<void>((resolve) => {+ finishValidation = resolve;+ });++ const Harness = () => {+ const [dialog, setDialog] = useState<"none" | "publish" | "export">(+ "publish"+ );+ const { validationState, update } = usePublishValidationState(dialog);+ return (+ <TooltipProvider>+ {dialog === "publish" && (+ <PublishActions+ validationState={validationState}+ validateDisabled={false}+ publishDisabled={false}+ publishInProgress={false}+ publishPending={false}+ hasSelectedDomains+ publishLabel="Publish"+ publishButtonRef={createRef<HTMLButtonElement>()}+ onValidate={async () => {+ await validation;+ update("passed");+ }}+ onPublish={vi.fn()}+ />+ )}+ <button type="button" onClick={() => setDialog(destination)}>+ Switch+ </button>+ <button type="button" onClick={() => setDialog("publish")}>+ Reopen+ </button>+ <output>{validationState}</output>+ </TooltipProvider>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [validate, , switchDialog, reopenDialog] =+ container.querySelectorAll("button");+ act(() => validate.click());+ act(() => switchDialog.click());+ if (reopen) {+ act(() => reopenDialog.click());+ }+ await act(async () => {+ finishValidation();+ await validation;+ });++ expect(successToast).toHaveBeenCalledTimes(expectedToasts);+ expect(container.querySelector("output")?.textContent).toBe(+ destination === "publish" || reopen ? "passed" : "idle"+ );+ }+);+test("shows the countdown and disables actions during publish progress", () => {const [validate, publish] = render("idle",diff --git a/apps/builder/app/builder/features/publish/publish-actions.tsx b/apps/builder/app/builder/features/publish/publish-actions.tsxindex bd078a355d..534d3a2068 100644--- a/apps/builder/app/builder/features/publish/publish-actions.tsx+++ b/apps/builder/app/builder/features/publish/publish-actions.tsx@@ -1,36 +1,38 @@import { useCallback, useEffect, useRef, useState, type Ref } from "react";-import { Button, Flex, Tooltip } from "@webstudio-is/design-system";+import { Button, Flex, Tooltip, toast } from "@webstudio-is/design-system";import { CheckCircleIcon } from "@webstudio-is/icons";export type PublishValidationState = "idle" | "passed";-export const usePublishValidationState = (isOpen: boolean) => {+export const usePublishValidationState = (+ dialog: "none" | "publish" | "export"+) => {const [validationState, setValidationState] =useState<PublishValidationState>("idle");- const session = useRef(0);- const sessionAtRender = session.current;- const isOpenRef = useRef(isOpen);- isOpenRef.current = isOpen;+ const dialogRef = useRef(dialog);+ dialogRef.current = dialog;const reset = useCallback(() => {- session.current += 1;setValidationState("idle");}, []);- const update = useCallback(- (state: PublishValidationState) => {- if (isOpenRef.current && session.current === sessionAtRender) {- setValidationState(state);- }- },- [sessionAtRender]- );+ const update = useCallback((state: PublishValidationState) => {+ if (state === "passed" && dialogRef.current !== "publish") {+ toast.success("Validation passed. Ready to publish.", {+ duration: Number.POSITIVE_INFINITY,+ });+ return;+ }+ if (dialogRef.current === "publish") {+ setValidationState(state);+ }+ }, []);useEffect(() => {- if (isOpen === false) {+ if (dialog !== "publish") {reset();}- }, [isOpen, reset]);+ }, [dialog, reset]);return { validationState, update, reset };};diff --git a/apps/builder/app/builder/features/publish/publish-progress.test.tsx b/apps/builder/app/builder/features/publish/publish-progress.test.tsxnew file mode 100644index 0000000000..554964ee94--- /dev/null+++ b/apps/builder/app/builder/features/publish/publish-progress.test.tsx@@ -0,0 +1,1185 @@+import { useState } from "react";+import { createRoot, type Root } from "react-dom/client";+import { act } from "react-dom/test-utils";+import { afterEach, expect, test, vi } from "vitest";+import { TooltipProvider, toast } from "@webstudio-is/design-system";+import type { Project } from "@webstudio-is/project";+import { $publishDialog } from "~/builder/shared/nano-states";+import { $project } from "~/shared/sync/data-stores";+import { __testing__ } from "./publish";+import { DomainCheckbox, domainToPublishName } from "./domain-checkbox";+import { PublishValidationResults } from "./publish-validation-results";++const {+ usePublishProgress,+ waitForPublishStatus,+ refreshUntilSuccess,+ useManualValidationFindings,+ getRefreshedProject,+ reportPublishResult,+} = __testing__;++let root: Root | undefined;+let container: HTMLDivElement | undefined;++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++afterEach(() => {+ act(() => root?.unmount());+ root = undefined;+ container?.remove();+ container = undefined;+ $publishDialog.set("none");+ $project.set(undefined);+ vi.useRealTimers();+ vi.restoreAllMocks();+});++test("closing publish hides the countdown while polling continues and completion clears pending", async () => {+ vi.useFakeTimers();+ vi.setSystemTime(new Date("2026-10-20T12:00:00Z"));+ $project.set({ id: "project" } as Project);++ let status: "PENDING" | "PUBLISHED" = "PENDING";+ let statusRequests = 0;++ const Harness = () => {+ const [isOpen, setIsOpen] = useState(true);+ const [completedStatus, setCompletedStatus] = useState<string>();+ const progress = usePublishProgress("project");+ return (+ <>+ <button+ onClick={() =>+ progress.start(async () => {+ const result = await waitForPublishStatus(+ async () => {+ statusRequests += 1;+ return {+ latestBuildVirtual: {+ createdAt: new Date().toISOString(),+ publishStatus: status,+ },+ } as Project;+ },+ () => true+ );+ setCompletedStatus(result?.status);+ })+ }+ >+ Start+ </button>+ <button+ onClick={() => {+ progress.dismissCountdown();+ setIsOpen(false);+ }}+ >+ Close+ </button>+ <button onClick={() => setIsOpen(true)}>Open</button>+ {isOpen && (+ <output>+ {progress.isPublishing ? "pending" : "complete"}:+ {progress.countdown ?? "no countdown"}:{completedStatus ?? "none"}+ </output>+ )}+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));++ const [start, close, open] = container.querySelectorAll("button");+ act(() => start.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "pending:60:none"+ );++ await act(async () => vi.advanceTimersByTimeAsync(10_000));+ expect(container.querySelector("output")?.textContent).toBe(+ "pending:50:none"+ );++ act(() => close.click());+ act(() => open.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "pending:no countdown:none"+ );++ act(() => close.click());+ status = "PUBLISHED";+ await act(async () => vi.advanceTimersByTimeAsync(5_000));+ act(() => open.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "complete:no countdown:PUBLISHED"+ );+ expect(statusRequests).toBe(2);+});++test("reopening refresh retries after a rejected status request", async () => {+ vi.useFakeTimers();+ const errorLog = vi.spyOn(console, "error").mockImplementation(() => {});+ let attempts = 0;+ const refresh = async (_showError: boolean) => {+ attempts += 1;+ if (attempts === 1) {+ throw new Error("Network unavailable");+ }+ return {} as Project;+ };++ try {+ const done = refreshUntilSuccess(refresh, () => true);+ expect(attempts).toBe(1);+ await vi.advanceTimersByTimeAsync(5_000);+ await done;+ expect(attempts).toBe(2);+ } finally {+ errorLog.mockRestore();+ }+});++test("reopening stops after three unsuccessful project refreshes and shows the error", async () => {+ vi.useFakeTimers();+ $project.set({ id: "project" } as Project);+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ const query = vi.fn(async () => ({+ success: false as const,+ error: "Not found",+ }));+ let isOpen = true;++ const done = refreshUntilSuccess(+ (showError) =>+ getRefreshedProject({ projectId: "project", showError, query }),+ () => isOpen+ );+ await vi.advanceTimersByTimeAsync(15_000);+ isOpen = false;+ await vi.runOnlyPendingTimersAsync();+ await done;++ expect(query).toHaveBeenCalledTimes(3);+ expect(errorToast).toHaveBeenCalledOnce();+});++test("a recovered pending build keeps polling after the popover closes", async () => {+ vi.useFakeTimers();+ $project.set({ id: "project" } as Project);+ $publishDialog.set("publish");+ const successToast = vi.spyOn(toast, "success").mockImplementation(() => "");+ let status: "PENDING" | "PUBLISHED" = "PENDING";+ let pollRequests = 0;+ const refreshedProject = () =>+ ({+ id: "project",+ latestBuildVirtual: {+ buildId: "recovered",+ createdAt: new Date().toISOString(),+ publishStatus: status,+ },+ }) as Project;++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <button+ onClick={() => {+ void refreshUntilSuccess(+ async () => refreshedProject(),+ () => true,+ () =>+ progress.watchPendingPublish(async () => {+ pollRequests += 1;+ return refreshedProject();+ })+ );+ }}+ >+ Recover+ </button>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ await act(async () => container?.querySelector("button")?.click());+ expect(pollRequests).toBe(1);++ $publishDialog.set("none");+ status = "PUBLISHED";+ await act(async () => vi.advanceTimersByTimeAsync(15_000));++ expect(pollRequests).toBe(2);+ expect(successToast).toHaveBeenCalledOnce();+});++test("an in-flight status request cannot replace the project after navigation", async () => {+ const oldProject = { id: "old-project" } as Project;+ const newProject = { id: "new-project" } as Project;+ $project.set(oldProject);++ let finishQuery: (result: {+ success: true;+ project: Project;+ }) => void = () => {};+ const query = new Promise<{ success: true; project: Project }>((resolve) => {+ finishQuery = resolve;+ });+ const refresh = getRefreshedProject({+ projectId: oldProject.id,+ showError: false,+ query: () => query,+ });++ $project.set(newProject);+ finishQuery({ success: true, project: oldProject });++ await expect(refresh).resolves.toBeUndefined();+ expect($project.get()).toBe(newProject);+});++test("an older popover refresh cannot overwrite a newer result", async () => {+ $project.set({ id: "project" } as Project);+ let finishOldQuery: (result: {+ success: true;+ project: Project;+ }) => void = () => {};+ const oldQuery = new Promise<{ success: true; project: Project }>(+ (resolve) => {+ finishOldQuery = resolve;+ }+ );+ let isOpen = true;+ const oldRefresh = getRefreshedProject({+ projectId: "project",+ showError: false,+ query: () => oldQuery,+ isCurrent: () => isOpen,+ });++ isOpen = false;+ const currentProject = { id: "project", domain: "new" } as Project;+ await getRefreshedProject({+ projectId: "project",+ showError: false,+ query: async () => ({ success: true, project: currentProject }),+ });+ finishOldQuery({+ success: true,+ project: { id: "project", domain: "old" } as Project,+ });+ await oldRefresh;++ expect($project.get()).toBe(currentProject);+});++test("an older recovered poll cannot overwrite a newer popover refresh", async () => {+ $project.set({ id: "project" } as Project);+ let progress: ReturnType<typeof usePublishProgress> | undefined;+ const Harness = () => {+ progress = usePublishProgress("project");+ return null;+ };+ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));++ let finishOldQuery: (result: {+ success: true;+ project: Project;+ }) => void = () => {};+ const oldQuery = new Promise<{ success: true; project: Project }>(+ (resolve) => {+ finishOldQuery = resolve;+ }+ );+ const oldGeneration = progress!.beginPopoverRefresh();+ const polling = progress!.watchPendingPublish(+ () =>+ getRefreshedProject({+ projectId: "project",+ query: () => oldQuery,+ isCurrent: () => progress!.isRefreshCurrent(oldGeneration),+ }),+ oldGeneration+ );++ const newGeneration = progress!.beginPopoverRefresh();+ const currentProject = { id: "project", domain: "new" } as Project;+ await getRefreshedProject({+ projectId: "project",+ query: async () => ({ success: true, project: currentProject }),+ isCurrent: () => progress!.isRefreshCurrent(newGeneration),+ });+ finishOldQuery({+ success: true,+ project: { id: "project", domain: "old" } as Project,+ });+ await polling;++ expect($project.get()).toBe(currentProject);+});++test("publish polling stops after navigating to another project", async () => {+ const oldProject = { id: "old-project" } as Project;+ const newProject = { id: "new-project" } as Project;+ $project.set(oldProject);++ let finishRefresh: (project: Project) => void = () => {};+ const refresh = new Promise<Project>((resolve) => {+ finishRefresh = resolve;+ });+ const polling = waitForPublishStatus(+ () => refresh,+ () => $project.get()?.id === oldProject.id+ );++ $project.set(newProject);+ finishRefresh({+ latestBuildVirtual: {+ createdAt: new Date().toISOString(),+ publishStatus: "PUBLISHED",+ },+ } as Project);++ await expect(polling).resolves.toBeUndefined();+ expect($project.get()).toBe(newProject);+});++test("an old poll cannot update a newly mounted copy of the same project", async () => {+ const firstProject = { id: "project" } as Project;+ $project.set(firstProject);+ let progress: ReturnType<typeof usePublishProgress> | undefined;+ const Harness = () => {+ progress = usePublishProgress("project");+ return null;+ };+ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));++ let finishQuery: (result: {+ success: true;+ project: Project;+ }) => void = () => {};+ const query = new Promise<{ success: true; project: Project }>((resolve) => {+ finishQuery = resolve;+ });+ const polling = waitForPublishStatus(+ () =>+ getRefreshedProject({+ projectId: "project",+ isCurrent: progress!.isCurrentProject,+ query: () => query,+ }),+ progress!.isCurrentProject+ );++ act(() => root?.unmount());+ $project.set({ id: "another-project" } as Project);+ const reopenedProject = { id: "project", domain: "new" } as Project;+ $project.set(reopenedProject);+ finishQuery({+ success: true,+ project: { id: "project", domain: "old" } as Project,+ });++ await expect(polling).resolves.toBeUndefined();+ expect($project.get()).toBe(reopenedProject);+});++test("publish completion does not show a toast while the Publish panel is open", () => {+ const successToast = vi.spyOn(toast, "success").mockImplementation(() => "");+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ const setPublishError = vi.fn();+ const publishedStatusText = <>Published</>;+ const failedStatusText = <>Publish failed</>;++ $publishDialog.set("publish");+ reportPublishResult({+ result: { status: "PUBLISHED", statusText: publishedStatusText },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError,+ });+ reportPublishResult({+ result: { status: "FAILED", statusText: failedStatusText },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError,+ });++ expect(successToast).not.toHaveBeenCalled();+ expect(errorToast).not.toHaveBeenCalled();+ expect(setPublishError).toHaveBeenCalledOnce();+});++test("an old project completion does not show a success toast over an open Publish panel", () => {+ const successToast = vi.spyOn(toast, "success").mockImplementation(() => "");+ $publishDialog.set("publish");++ reportPublishResult({+ result: { status: "PUBLISHED", statusText: <>Published</> },+ setPublishError: vi.fn(),+ isCurrentProject: () => false,+ });++ expect(successToast).not.toHaveBeenCalled();+});++test("publish completion does not show a success toast in the Export view", () => {+ const successToast = vi.spyOn(toast, "success").mockImplementation(() => "");+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ const setPublishError = vi.fn();+ $publishDialog.set("export");++ reportPublishResult({+ result: { status: "PUBLISHED", statusText: <>Published</> },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError,+ });+ reportPublishResult({+ result: { status: "FAILED", statusText: <>Publish failed</> },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError,+ });++ expect(successToast).not.toHaveBeenCalled();+ expect(errorToast).toHaveBeenCalledOnce();+});++test("publish completion shows a toast after the dialog closes", () => {+ const successToast = vi.spyOn(toast, "success").mockImplementation(() => "");+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ const setPublishError = vi.fn();+ const publishedStatusText = <>Published</>;+ const failedStatusText = <>Publish failed</>;+ $publishDialog.set("none");++ reportPublishResult({+ result: { status: "PUBLISHED", statusText: publishedStatusText },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError,+ });+ reportPublishResult({+ result: { status: "FAILED", statusText: failedStatusText },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError,+ });++ expect(successToast).toHaveBeenCalledOnce();+ expect(errorToast).toHaveBeenCalledOnce();+ expect(setPublishError).toHaveBeenCalledWith(failedStatusText);+});++test("a rejected publish request shows an inline error while the dialog is open", async () => {+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ $publishDialog.set("publish");+ $project.set({ id: "project" } as Project);++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button+ onClick={() =>+ progress.start(() =>+ Promise.reject(new Error("Network unavailable"))+ )+ }+ >+ Start+ </button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));++ await act(async () => container?.querySelector("button")?.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "Network unavailable"+ );+ expect(errorToast).not.toHaveBeenCalled();+});++test("starting validation clears a previous request failure", async () => {+ $project.set({ id: "project" } as Project);+ $publishDialog.set("publish");++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button+ onClick={() =>+ progress.start(() =>+ Promise.reject(new Error("Network unavailable"))+ )+ }+ >+ Publish+ </button>+ <button onClick={progress.clearErrors}>Validate</button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [publish, validate] = container.querySelectorAll("button");+ await act(async () => publish.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "Network unavailable"+ );+ act(() => validate.click());+ expect(container.querySelector("output")?.textContent).toBe("");+});++test("a rejected publish request shows a toast after the dialog closes", async () => {+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ $publishDialog.set("publish");+ $project.set({ id: "project" } as Project);+ let rejectPublish: (error: Error) => void = () => {};+ const publish = new Promise<void>((_, reject) => {+ rejectPublish = reject;+ });++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button onClick={() => progress.start(() => publish)}>Start</button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ act(() => container?.querySelector("button")?.click());++ $publishDialog.set("none");+ await act(async () => rejectPublish(new Error("Network unavailable")));++ expect(errorToast).toHaveBeenCalledOnce();+ expect(container.querySelector("output")?.textContent).toBe(+ "Network unavailable"+ );+});++test("a rejected publish request appears in the panel reopened before rejection", async () => {+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ $publishDialog.set("publish");+ $project.set({ id: "project" } as Project);+ let rejectPublish: (error: Error) => void = () => {};+ const publish = new Promise<void>((_, reject) => {+ rejectPublish = reject;+ });++ const Harness = () => {+ const [isOpen, setIsOpen] = useState(true);+ const progress = usePublishProgress("project");+ return (+ <>+ <button onClick={() => progress.start(() => publish)}>Start</button>+ <button+ onClick={() => {+ setIsOpen(false);+ $publishDialog.set("none");+ }}+ >+ Close+ </button>+ <button+ onClick={() => {+ setIsOpen(true);+ $publishDialog.set("publish");+ }}+ >+ Reopen+ </button>+ {isOpen && <output>{progress.publishError}</output>}+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [start, close, reopen] = container.querySelectorAll("button");+ act(() => start.click());+ act(() => close.click());+ act(() => reopen.click());++ await act(async () => rejectPublish(new Error("Network unavailable")));++ expect(container.querySelector("output")?.textContent).toBe(+ "Network unavailable"+ );+ expect(errorToast).not.toHaveBeenCalled();+});++test("a publish failure remains visible after the panel remounts", () => {+ $project.set({ id: "project" } as Project);+ $publishDialog.set("publish");+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");++ const Harness = () => {+ const [isOpen, setIsOpen] = useState(true);+ const progress = usePublishProgress("project");+ return (+ <>+ <button onClick={() => setIsOpen(false)}>Close</button>+ <button onClick={() => setIsOpen(true)}>Reopen</button>+ <button+ onClick={() =>+ reportPublishResult({+ result: { status: "FAILED", statusText: <>Build failed</> },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError: progress.setPublishStatusError,+ })+ }+ >+ Finish+ </button>+ {isOpen && <output>{progress.publishError}</output>}+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [close, reopen, finish] = container.querySelectorAll("button");+ act(() => close.click());+ act(() => reopen.click());+ act(() => finish.click());++ expect(container.querySelector("output")?.textContent).toBe("Build failed");+ expect(errorToast).not.toHaveBeenCalled();+});++test("a successful status refresh clears a persisted publish failure", () => {+ $project.set({ id: "project" } as Project);+ $publishDialog.set("publish");++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button+ onClick={() =>+ reportPublishResult({+ result: { status: "FAILED", statusText: <>Publish failed</> },+ timesLeft: 11,+ maxDailyPublishesPerUser: 20,+ setPublishError: progress.setPublishStatusError,+ })+ }+ >+ Fail+ </button>+ <button+ onClick={() =>+ progress.reconcileRefreshedProject({+ latestBuildVirtual: {+ createdAt: new Date().toISOString(),+ publishStatus: "PUBLISHED",+ },+ } as Project)+ }+ >+ Refresh+ </button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [fail, refresh] = container.querySelectorAll("button");+ act(() => fail.click());+ expect(container.querySelector("output")?.textContent).toBe("Publish failed");+ act(() => refresh.click());+ expect(container.querySelector("output")?.textContent).toBe("");+});++test("refreshing a project without a build clears a status error but preserves a request error", () => {+ $project.set({ id: "project" } as Project);++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button+ onClick={() => progress.setPublishStatusError("Publish failed")}+ >+ Fail+ </button>+ <button onClick={() => progress.setPublishError("Request rejected")}>+ Reject+ </button>+ <button+ onClick={() =>+ progress.reconcileRefreshedProject({+ latestBuildVirtual: null,+ } as Project)+ }+ >+ Refresh+ </button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [fail, reject, refresh] = container.querySelectorAll("button");++ act(() => fail.click());+ expect(container.querySelector("output")?.textContent).toBe("Publish failed");+ act(() => refresh.click());+ expect(container.querySelector("output")?.textContent).toBe("");++ act(() => reject.click());+ act(() => refresh.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "Request rejected"+ );+});++test("refreshing an older published build preserves a rejected request error", () => {+ $project.set({ id: "project" } as Project);+ const oldPublishedProject = {+ id: "project",+ latestBuildVirtual: {+ createdAt: new Date().toISOString(),+ publishStatus: "PUBLISHED",+ },+ } as Project;++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button onClick={() => progress.setPublishError(<>Request rejected</>)}>+ Reject+ </button>+ <button+ onClick={() =>+ progress.reconcileRefreshedProject(oldPublishedProject)+ }+ >+ Refresh+ </button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [reject, refresh] = container.querySelectorAll("button");+ act(() => reject.click());+ act(() => refresh.click());++ expect(container.querySelector("output")?.textContent).toBe(+ "Request rejected"+ );+});++test("a newer build clears a recovered transport error", async () => {+ $project.set({+ id: "project",+ latestBuildVirtual: { buildId: "old" },+ } as Project);+ $publishDialog.set("publish");++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button+ onClick={() =>+ progress.start(() =>+ Promise.reject(new Error("Network unavailable"))+ )+ }+ >+ Publish+ </button>+ <button+ onClick={() =>+ progress.reconcileRefreshedProject({+ latestBuildVirtual: {+ buildId: "old",+ createdAt: new Date().toISOString(),+ publishStatus: "PUBLISHED",+ },+ } as Project)+ }+ >+ Old build+ </button>+ <button+ onClick={() =>+ progress.reconcileRefreshedProject({+ latestBuildVirtual: {+ buildId: "new",+ createdAt: new Date().toISOString(),+ publishStatus: "PUBLISHED",+ },+ } as Project)+ }+ >+ Refresh+ </button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [publish, oldBuild, refresh] = container.querySelectorAll("button");+ await act(async () => publish.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "Network unavailable"+ );+ act(() => oldBuild.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "Network unavailable"+ );+ act(() => refresh.click());+ expect(container.querySelector("output")?.textContent).toBe("");+});++test("a recovered failed build replaces a lost response error", async () => {+ $project.set({+ id: "project",+ latestBuildVirtual: { buildId: "old" },+ } as Project);+ $publishDialog.set("publish");++ const Harness = () => {+ const progress = usePublishProgress("project");+ return (+ <>+ <button+ onClick={() =>+ progress.start(() =>+ Promise.reject(new Error("Network unavailable"))+ )+ }+ >+ Publish+ </button>+ <button+ onClick={() =>+ progress.reconcileRefreshedProject({+ latestBuildVirtual: {+ buildId: "new",+ createdAt: new Date().toISOString(),+ publishStatus: "FAILED",+ },+ } as Project)+ }+ >+ Refresh+ </button>+ <output>{progress.publishError}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [publish, refresh] = container.querySelectorAll("button");+ await act(async () => publish.click());+ expect(container.querySelector("output")?.textContent).toBe(+ "Network unavailable"+ );+ act(() => refresh.click());+ expect(container.querySelector("output")?.textContent).toContain(+ "Publish failed"+ );+});++test("publish diagnostics remain visible after the panel remounts", () => {+ $project.set({ id: "project" } as Project);++ const Harness = () => {+ const [isOpen, setIsOpen] = useState(true);+ const progress = usePublishProgress("project");+ return (+ <>+ <button onClick={() => setIsOpen(false)}>Close</button>+ <button onClick={() => setIsOpen(true)}>Reopen</button>+ <button+ onClick={() =>+ progress.setPublishFindings([+ {+ severity: "warning",+ title: "Check",+ reportText: "Check",+ },+ ])+ }+ >+ Finish diagnostics+ </button>+ {isOpen && <output>{progress.publishFindings.length}</output>}+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [close, reopen, finish] = container.querySelectorAll("button");+ act(() => close.click());+ act(() => reopen.click());+ act(() => finish.click());++ expect(container.querySelector("output")?.textContent).toBe("1");+});++test("an older validation cannot replace newer findings", () => {+ const finish: ((title: string) => void)[] = [];++ const Harness = () => {+ const validation = useManualValidationFindings();+ return (+ <>+ <button+ onClick={() => {+ const session = validation.begin();+ finish.push((title) =>+ validation.update(session, [+ { severity: "warning", title, reportText: title },+ ])+ );+ }}+ >+ Validate+ </button>+ <output>{validation.findings[0]?.title}</output>+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const validate = container.querySelector("button")!;+ act(() => validate.click());+ act(() => validate.click());+ act(() => finish[1]("new"));+ act(() => finish[0]("old"));++ expect(container.querySelector("output")?.textContent).toBe("new");+});++test("manual validation report stays available after the popover reopens", () => {+ const Harness = () => {+ const [isOpen, setIsOpen] = useState(true);+ const { manualValidationFindings } = usePublishProgress("project");+ return (+ <>+ <button onClick={() => setIsOpen(false)}>Close</button>+ <button onClick={() => setIsOpen(true)}>Reopen</button>+ <button+ onClick={() => {+ const session = manualValidationFindings.begin();+ manualValidationFindings.update(session, [+ { severity: "warning", title: "Check", reportText: "Check" },+ ]);+ }}+ >+ Validate+ </button>+ {isOpen && (+ <PublishValidationResults+ findings={manualValidationFindings.findings}+ />+ )}+ </>+ );+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ const [close, reopen, validate] = container.querySelectorAll("button");+ act(() => validate.click());+ expect(container.textContent).toContain("Publish check found 1 warning.");+ act(() => close.click());+ act(() => reopen.click());+ expect(container.textContent).toContain("Publish check found 1 warning.");+ expect(+ [...container.querySelectorAll("button")].some(+ (button) => button.textContent === "See issues"+ )+ ).toBe(true);+});++test("reopening shows the domains used by the validation report and submits only those domains", () => {+ let validation: ReturnType<typeof useManualValidationFindings> | undefined;+ const Harness = () => {+ validation = useManualValidationFindings();+ return null;+ };+ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ act(() => {+ const session = validation!.begin(["custom.example"]);+ validation!.update(session, [+ { severity: "warning", title: "Check", reportText: "Check" },+ ]);+ });++ act(() => root?.unmount());+ $project.set({+ id: "project",+ domainsVirtual: [{ status: "ACTIVE", verified: true }],+ } as Project);+ root = createRoot(container);+ const renderCheckboxes = (validatedDomains?: string[]) =>+ act(() =>+ root?.render(+ <TooltipProvider>+ <form>+ <DomainCheckbox+ domain="staging.example"+ buildId={undefined}+ defaultChecked+ validatedDomains={validatedDomains}+ />+ <DomainCheckbox+ domain="custom.example"+ buildId={undefined}+ defaultChecked={false}+ validatedDomains={validatedDomains}+ />+ </form>+ </TooltipProvider>+ )+ );+ renderCheckboxes();++ const form = container.querySelector("form")!;+ const [staging, custom] = form.querySelectorAll('[role="checkbox"]');+ expect(staging.getAttribute("aria-checked")).toBe("true");+ expect(custom.getAttribute("aria-checked")).toBe("false");++ renderCheckboxes(validation!.domains);+ expect(staging.getAttribute("aria-checked")).toBe("false");+ expect(custom.getAttribute("aria-checked")).toBe("true");+ expect([...new FormData(form).getAll(domainToPublishName)]).toEqual([+ "custom.example",+ ]);+ act(() => (custom as HTMLButtonElement).click());+ renderCheckboxes();+ expect(custom.getAttribute("aria-checked")).toBe("false");+ expect([...new FormData(form).getAll(domainToPublishName)]).toEqual([]);+});++test("older publish diagnostics cannot replace a newer operation", () => {+ let progress: ReturnType<typeof usePublishProgress> | undefined;+ const Harness = () => {+ progress = usePublishProgress("project");+ return <output>{progress.publishFindings[0]?.title}</output>;+ };+ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));++ const oldAttempt = progress!.beginPublishDiagnostics();+ const currentAttempt = progress!.beginPublishDiagnostics();+ act(() =>+ currentAttempt.setFindings([+ { severity: "warning", title: "New", reportText: "New" },+ ])+ );+ act(() =>+ oldAttempt.setFindings([+ { severity: "warning", title: "Old", reportText: "Old" },+ ])+ );++ expect(oldAttempt.isCurrent()).toBe(false);+ expect(container.querySelector("output")?.textContent).toBe("New");+});++test("a rejected request after project navigation shows a toast", async () => {+ $project.set({ id: "old-project" } as Project);+ $publishDialog.set("publish");+ const errorToast = vi.spyOn(toast, "error").mockImplementation(() => "");+ let rejectPublish: (error: Error) => void = () => {};+ const publish = new Promise<void>((_, reject) => {+ rejectPublish = reject;+ });++ const Harness = () => {+ const progress = usePublishProgress("old-project");+ return <button onClick={() => progress.start(() => publish)}>Start</button>;+ };++ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ act(() => root?.render(<Harness />));+ act(() => container?.querySelector("button")?.click());+ act(() => root?.unmount());+ $project.set({ id: "new-project" } as Project);++ await act(async () => rejectPublish(new Error("Network unavailable")));+ expect(errorToast).toHaveBeenCalledOnce();+});diff --git a/apps/builder/app/builder/features/publish/publish.tsx b/apps/builder/app/builder/features/publish/publish.tsxindex 576fbee177..e4da6b4392 100644--- a/apps/builder/app/builder/features/publish/publish.tsx+++ b/apps/builder/app/builder/features/publish/publish.tsx@@ -1,6 +1,7 @@import stripIndent from "strip-indent";import { computed } from "nanostores";import {+ useCallback,useEffect,useState,useOptimistic,@@ -123,11 +124,7 @@ import {PublishValidationResults,type PublishValidationFinding,} from "./publish-validation-results";-import {- PublishActions,- usePublishValidationState,- type PublishValidationState,-} from "./publish-actions";+import { PublishActions, usePublishValidationState } from "./publish-actions";import { flushExternalContentProject } from "~/shared/external-content-roots";import { getPublishValidationErrorMessage } from "./publish-error";import { runPublishAfterBestEffortChecks } from "./publish-preflight";@@ -354,11 +351,13 @@ type ChangeProjectDomainProps = {project: Project;projectState: "idle" | "submitting";refresh: () => Promise<void>;+ validatedDomains?: readonly string[];};const ChangeProjectDomain = ({project,refresh,+ validatedDomains,}: ChangeProjectDomainProps) => {const id = useId();const currentSystem = useStore($currentSystem);@@ -442,6 +441,7 @@ const ChangeProjectDomain = ({prefix={<DomainCheckboxdefaultChecked={latestProjectDomainBuild?.domain === domain}+ validatedDomains={validatedDomains}buildId={latestProjectDomainBuild?.buildId}domain={domain}/>@@ -585,32 +585,370 @@ const $restrictedFeatures = computed(}));-const usePublishCountdown = (isPublishing: boolean) => {- const [countdown, setCountdown] = useState<number | undefined>(undefined);+const COUNTDOWN_DURATION = 60_000;+const STATUS_REFRESH_RETRY_DELAY = 5_000;+const STATUS_REFRESH_MAX_ATTEMPTS = 3;++const usePublishProgress = (projectId: Project["id"]) => {+ const manualValidationFindings = useManualValidationFindings();+ const [startedAt, setStartedAt] = useState<number>();+ const [showCountdown, setShowCountdown] = useState(false);+ const [isPublishing, setIsPublishing] = useState(false);+ const [publishFindings, setPublishFindings] = useState<+ PublishValidationFinding[]+ >([]);+ const publishDiagnosticsSession = useRef(0);+ const [publishErrorState, setPublishErrorState] = useState<{+ value: JSX.Element | string;+ source: "request" | "transport" | "status";+ }>();+ const [now, setNow] = useState(Date.now);+ const isMounted = useRef(false);+ const requestBaselineBuildId = useRef<string>();+ const hasStartedPublishRequest = useRef(false);+ const refreshGeneration = useRef(0);+ const recoveredPoll = useRef<{+ generation: number;+ promise: Promise<void>;+ }>();useEffect(() => {- if (isPublishing === false) {- setCountdown(undefined);+ isMounted.current = true;+ return () => {+ isMounted.current = false;+ };+ }, []);++ const isCurrentProject = useCallback(+ () => isMounted.current && $project.get()?.id === projectId,+ [projectId]+ );++ const beginPopoverRefresh = useCallback(() => {+ refreshGeneration.current += 1;+ return refreshGeneration.current;+ }, []);++ const isRefreshCurrent = useCallback(+ (generation: number) =>+ isCurrentProject() && refreshGeneration.current === generation,+ [isCurrentProject]+ );++ const setPublishError = (value: JSX.Element | string | undefined) => {+ setPublishErrorState(+ value === undefined ? undefined : { value, source: "request" }+ );+ };++ const setPublishStatusError = useCallback((value: JSX.Element | string) => {+ setPublishErrorState({ value, source: "status" });+ }, []);++ const clearErrors = useCallback(() => {+ setPublishErrorState(undefined);+ }, []);++ const beginPublishDiagnostics = useCallback(() => {+ const session = ++publishDiagnosticsSession.current;+ setPublishFindings([]);+ return {+ isCurrent: () => publishDiagnosticsSession.current === session,+ setFindings: (findings: PublishValidationFinding[]) => {+ if (publishDiagnosticsSession.current === session) {+ setPublishFindings(findings);+ }+ },+ };+ }, []);++ const reconcileRefreshedProject = useCallback((project: Project) => {+ const build = project.latestBuildVirtual;+ if (build == null) {+ setPublishErrorState((current) =>+ current?.source === "status" ? undefined : current+ );+ return;+ }+ const { status, statusText } = getPublishStatusAndText(build);+ const isNewBuild =+ build.buildId !== undefined &&+ build.buildId !== requestBaselineBuildId.current;+ if (status === "FAILED") {+ if (hasStartedPublishRequest.current && isNewBuild) {+ setPublishErrorState({ value: statusText, source: "status" });+ }+ } else {+ setPublishErrorState((current) =>+ current?.source === "status" ||+ (isNewBuild && current?.source === "transport")+ ? undefined+ : current+ );+ }+ }, []);++ const watchPendingPublish = useCallback(+ (+ refresh: () => Promise<Project | undefined>,+ generation = refreshGeneration.current+ ) => {+ if (recoveredPoll.current?.generation === generation) {+ return recoveredPoll.current.promise;+ }+ const polling = waitForPublishStatus(refresh, () =>+ isRefreshCurrent(generation)+ )+ .then((result) => {+ if (isRefreshCurrent(generation) === false) {+ return;+ }+ reportPublishResult({+ result,+ setPublishError: setPublishStatusError,+ isCurrentProject,+ });+ })+ .finally(() => {+ if (recoveredPoll.current?.promise === polling) {+ recoveredPoll.current = undefined;+ }+ });+ recoveredPoll.current = { generation, promise: polling };+ return polling;+ },+ [isCurrentProject, isRefreshCurrent, setPublishStatusError]+ );++ useEffect(() => {+ if (isPublishing === false || showCountdown === false) {return;}+ const interval = setInterval(() => setNow(Date.now()), 1000);+ return () => clearInterval(interval);+ }, [isPublishing, showCountdown]);++ const countdown =+ isPublishing && showCountdown && startedAt !== undefined+ ? Math.max(0, Math.ceil((COUNTDOWN_DURATION - (now - startedAt)) / 1000))+ : undefined;++ const dismissCountdown = useCallback(() => setShowCountdown(false), []);++ const start = (publish: () => Promise<void>) => {+ const startedAt = Date.now();+ hasStartedPublishRequest.current = true;+ requestBaselineBuildId.current =+ $project.get()?.latestBuildVirtual?.buildId;+ setStartedAt(startedAt);+ setNow(startedAt);+ setShowCountdown(true);+ setIsPublishing(true);+ setPublishErrorState(undefined);+ publish()+ .catch((error) => {+ console.error(error);+ const message =+ error instanceof Error ? error.message : "Unknown error";+ if (isCurrentProject()) {+ setPublishErrorState({ value: message, source: "transport" });+ }+ if ($publishDialog.get() !== "publish" || !isCurrentProject()) {+ toast.error(message);+ }+ })+ .finally(() => setIsPublishing(false));+ };++ return {+ manualValidationFindings,+ isPublishing,+ publishFindings,+ setPublishFindings,+ beginPublishDiagnostics,+ publishError: publishErrorState?.value,+ setPublishError,+ setPublishStatusError,+ clearErrors,+ isCurrentProject,+ beginPopoverRefresh,+ isRefreshCurrent,+ reconcileRefreshedProject,+ watchPendingPublish,+ countdown,+ start,+ dismissCountdown,+ };+};++const waitForPublishStatus = async (+ refresh: () => Promise<Project | undefined>,+ isCurrentProject: () => boolean+) => {+ let sleepTime = 15000;+ const timeToFinish = Date.now() + PENDING_TIMEOUT + 2 * sleepTime;++ while (Date.now() < timeToFinish && isCurrentProject()) {+ try {+ const refreshedProject = await refresh();+ if (isCurrentProject() === false) {+ return;+ }+ if (refreshedProject !== undefined) {+ const { statusText, status } =+ refreshedProject.latestBuildVirtual != null+ ? getPublishStatusAndText(refreshedProject.latestBuildVirtual)+ : {+ statusText: "Not published",+ status: "PENDING" as const,+ };++ if (status === "PUBLISHED" || status === "FAILED") {+ return { status, statusText };+ }+ }+ } catch (error) {+ if (isCurrentProject() === false) {+ return;+ }+ // A failed status request should not stop watching an ongoing publish.+ console.error("Could not refresh publish status", error);+ }- setCountdown(60);+ await new Promise((resolve) => setTimeout(resolve, sleepTime));+ sleepTime = Math.max(5000, sleepTime - 5000);+ }+};- const interval = setInterval(() => {- setCountdown((prev) => {- if (prev === undefined || prev <= 0) {- return 0;+const refreshUntilSuccess = async (+ refresh: (showError: boolean) => Promise<Project | undefined>,+ isOpen: () => boolean,+ onPending: (project: Project) => void = () => {}+) => {+ for (+ let attempt = 1;+ attempt <= STATUS_REFRESH_MAX_ATTEMPTS && isOpen();+ attempt+++ ) {+ const isLastAttempt = attempt === STATUS_REFRESH_MAX_ATTEMPTS;+ try {+ const refreshedProject = await refresh(isLastAttempt);+ if (refreshedProject !== undefined) {+ if (+ refreshedProject.latestBuildVirtual != null &&+ getPublishStatusAndText(refreshedProject.latestBuildVirtual)+ .status === "PENDING"+ ) {+ onPending(refreshedProject);}- return prev - 1;- });- }, 1000);+ return;+ }+ } catch (error) {+ console.error("Could not refresh publish status", error);+ if (isLastAttempt && isOpen()) {+ toast.error(error instanceof Error ? error.message : "Unknown error");+ }+ }++ if (isLastAttempt === false && isOpen()) {+ await new Promise((resolve) =>+ setTimeout(resolve, STATUS_REFRESH_RETRY_DELAY)+ );+ }+ }+};++const reportPublishResult = ({+ result,+ timesLeft,+ maxDailyPublishesPerUser,+ setPublishError,+ isCurrentProject = () => true,+}: {+ result: Awaited<ReturnType<typeof waitForPublishStatus>>;+ timesLeft?: number;+ maxDailyPublishesPerUser?: number;+ setPublishError: (error: string | JSX.Element) => void;+ isCurrentProject?: () => boolean;+}) => {+ if (result?.status === "PUBLISHED") {+ if ($publishDialog.get() === "none") {+ toast.success(+ <>+ The project has been successfully published.{" "}+ {timesLeft !== undefined &&+ maxDailyPublishesPerUser !== undefined &&+ timesLeft > 0 &&+ timesLeft <= 10 && (+ <div>+ You have {timesLeft} out of {maxDailyPublishesPerUser} daily+ publications remaining. The counter resets tomorrow.+ </div>+ )}+ </>,+ { duration: 10000 }+ );+ }+ return;+ }+ if (result?.status === "FAILED") {+ if ($publishDialog.get() !== "publish" || !isCurrentProject()) {+ toast.error(result.statusText);+ }+ if (isCurrentProject()) {+ setPublishError(result.statusText);+ }+ }+};++const useManualValidationFindings = () => {+ const [findings, setFindings] = useState<PublishValidationFinding[]>([]);+ const [domains, setDomains] = useState<string[]>();+ const session = useRef(0);+ const requestedDomains = useRef<string[]>([]);++ useEffect(() => {return () => {- clearInterval(interval);+ session.current += 1;};- }, [isPublishing]);+ }, []);++ const begin = useCallback((domains: string[] = []) => {+ session.current += 1;+ requestedDomains.current = domains;+ setFindings([]);+ setDomains(undefined);+ return session.current;+ }, []);++ const invalidate = useCallback(() => {+ session.current += 1;+ setFindings([]);+ setDomains(undefined);+ }, []);++ const isCurrent = useCallback((id: number) => session.current === id, []);++ const update = useCallback((id: number, next: PublishValidationFinding[]) => {+ if (session.current === id) {+ setFindings(next);+ setDomains(next.length > 0 ? requestedDomains.current : undefined);+ }+ }, []);++ return { findings, domains, begin, invalidate, isCurrent, update };+};- return countdown;+const matchesValidatedDomains = (form: HTMLFormElement, domains: string[]) => {+ const selected = new Set(domains);+ const current = new FormData(form)+ .getAll(domainToPublishName)+ .map((domain) => domain.toString());+ return (+ current.length === selected.size &&+ current.every((domain) => selected.has(domain))+ );};const Publish = ({@@ -619,28 +957,22 @@ const Publish = ({disabled,refresh,restrictedFeatures,- validationState,- onValidationStateChange,- isPublishing,- setIsPublishing,+ validation,+ progress,}: {project: Project;timesLeft: number;disabled: boolean;refresh: () => Promise<void>;restrictedFeatures: Map<string, RestrictedFeature>;- validationState: PublishValidationState;- onValidationStateChange: (state: PublishValidationState) => void;- isPublishing: boolean;- setIsPublishing: (isPublishing: boolean) => void;+ validation: ReturnType<typeof usePublishValidationState>;+ progress: ReturnType<typeof usePublishProgress>;}) => {+ const validationFindings = progress.manualValidationFindings;+ const { countdown, isCurrentProject } = progress;+ const { validationState, update: onValidationStateChange } = validation;const { userPublishCount, maxDailyPublishesPerUser } = useUserPublishCount();- const [publishError, setPublishError] = useState<- undefined | JSX.Element | string- >();- const [publishFindings, setPublishFindings] = useState<- PublishValidationFinding[]- >([]);+ const { invalidate: invalidateValidationFindings } = validationFindings;const buttonRef = useRef<HTMLButtonElement>(null);const [hasSelectedDomains, setHasSelectedDomains] = useState(false);const [hasCustomDomainsSelected, setHasCustomDomainsSelected] =@@ -649,8 +981,7 @@ const Publish = ({const hasPendingState = project.latestBuildVirtual? getPublishStatusAndText(project.latestBuildVirtual).status === "PENDING": false;- const isPublishInProgress = isPublishing || hasPendingState;- const countdown = usePublishCountdown(isPublishInProgress);+ const isPublishInProgress = progress.isPublishing || hasPendingState;useEffect(() => {const form = buttonRef.current?.closest("form");@@ -670,6 +1001,7 @@ const Publish = ({previousDomainsKey.current !== undefined &&previousDomainsKey.current !== domainsKey) {+ invalidateValidationFindings();onValidationStateChange("idle");}previousDomainsKey.current = domainsKey;@@ -695,12 +1027,25 @@ const Publish = ({attributeFilter: ["value", "checked"],});+ if (validationFindings.domains !== undefined) {+ if (matchesValidatedDomains(form, validationFindings.domains)) {+ previousDomainsKey.current = validationFindings.domains.join("\u0000");+ } else {+ invalidateValidationFindings();+ }+ }+handleFormInput();return () => {observer.disconnect();};- }, [onValidationStateChange, project.domain]);+ }, [+ invalidateValidationFindings,+ onValidationStateChange,+ project.domain,+ validationFindings.domains,+ ]);const publish = async (domains: string[]) => {const publishResult = await nativeClient.domain.publish.mutate({@@ -733,11 +1078,13 @@ const Publish = ({</>);}- setPublishError(error);- if (publishResult.error === "NOT_IMPLEMENTED") {- toast.info(error);- } else {- toast.error(error);+ progress.setPublishError(error);+ if ($publishDialog.get() !== "publish" || !isCurrentProject()) {+ if (publishResult.error === "NOT_IMPLEMENTED") {+ toast.info(error);+ } else {+ toast.error(error);+ }}if (process.env.NODE_ENV === "development") {@@ -748,53 +1095,21 @@ const Publish = ({return;}- let sleepTime = 15000;- const timeToFinish = Date.now() + PENDING_TIMEOUT + 2 * sleepTime;-- // Wait until project is published or failed- while (Date.now() < timeToFinish) {- await refresh();-- const project = $project.get();-- if (project == null) {- throw new Error("Project not found");- }-- const { statusText, status } =- project.latestBuildVirtual != null- ? getPublishStatusAndText(project.latestBuildVirtual)- : {- statusText: "Not published",- status: "PENDING" as const,- };-- if (status === "PUBLISHED") {- toast.success(- <>- The project has been successfully published.{" "}- {timesLeft > 0 && timesLeft <= 10 && (- <div>- You have {timesLeft} out of {maxDailyPublishesPerUser} daily- publications remaining. The counter resets tomorrow.- </div>- )}- </>,- { duration: 10000 }- );- break;- }-- if (status === "FAILED") {- toast.error(statusText);- setPublishError(statusText);- break;- }-- await new Promise((resolve) => setTimeout(resolve, sleepTime));-- sleepTime = Math.max(5000, sleepTime - 5000);- }+ const result = await waitForPublishStatus(+ () =>+ getRefreshedProject({+ projectId: project.id,+ isCurrent: isCurrentProject,+ }),+ isCurrentProject+ );+ reportPublishResult({+ result,+ timesLeft,+ maxDailyPublishesPerUser,+ setPublishError: progress.setPublishStatusError,+ isCurrentProject,+ });};const getDomainsFromForm = (formData: FormData) =>@@ -803,9 +1118,10 @@ const Publish = ({.map((domainEntry) => domainEntry.toString());const handleValidate = async (formData: FormData) => {- setPublishError(undefined);- setPublishFindings([]);const domains = getDomainsFromForm(formData);+ const session = validationFindings.begin(domains);+ progress.clearErrors();+ progress.beginPublishDiagnostics();if (domains.length === 0) {toast.error("Please select at least one domain to publish");return;@@ -813,24 +1129,30 @@ const Publish = ({try {const checks = await runPublishValidation(project.id, domains);- setPublishFindings(checks.findings);+ if (validationFindings.isCurrent(session) === false) {+ return;+ }+ validationFindings.update(session, checks.findings);if (checks.passed === false) {onValidationStateChange("idle");return;}onValidationStateChange("passed");- toast.success("Validation passed. Ready to publish.", {- duration: Number.POSITIVE_INFINITY,- });} catch (error) {+ if (validationFindings.isCurrent(session) === false) {+ return;+ }onValidationStateChange("idle");- reportPublishValidationFailure(error, setPublishFindings);+ reportPublishValidationFailure(error, (findings) =>+ validationFindings.update(session, findings)+ );}};const handlePublish = (formData: FormData) => {- setPublishError(undefined);- setPublishFindings([]);+ validationFindings.invalidate();+ progress.clearErrors();+ const diagnostics = progress.beginPublishDiagnostics();// Custom domain checkboxes are disabled on free plan so they are never// submitted — only the staging (wstd.io) domain can appear in formData.@@ -841,31 +1163,41 @@ const Publish = ({return;}- if (blockPublishOnLocalErrors(setPublishFindings)) {+ if (blockPublishOnLocalErrors(diagnostics.setFindings)) {onValidationStateChange("idle");return;}- startTransition(async () => {- setIsPublishing(true);- await runPublishAfterBestEffortChecks({+ progress.start(() =>+ runPublishAfterBestEffortChecks({checks: async () => {const checks = await runPublishDiagnostics(project.id);- setPublishFindings(checks.findings);+ diagnostics.setFindings(checks.findings);+ },+ onCheckFailure: (error) => {+ if (diagnostics.isCurrent()) {+ reportPublishValidationFailure(+ error,+ diagnostics.setFindings,+ true+ );+ }},- onCheckFailure: (error) =>- reportPublishValidationFailure(error, setPublishFindings, true),publish: () => publish(domains),- });- });+ })+ );};const getForm = () => buttonRef.current?.closest("form");return (<Flex gap={2} shrink={false} direction={"column"}>- <PublishValidationResults findings={publishFindings} />- {publishError && <Text color="destructive">{publishError}</Text>}+ <PublishValidationResults+ findings={[...validationFindings.findings, ...progress.publishFindings]}+ />+ {progress.publishError && (+ <Text color="destructive">{progress.publishError}</Text>+ )}<PublishActionspublishButtonRef={buttonRef}validationState={validationState}@@ -1107,21 +1439,38 @@ const useUserPublishCount = () => {};};-const refreshProject = async () => {- const result = await nativeClient.domain.project.query(- {- projectId: $project.get()!.id,- }- // Pass abort signal- // { signal: undefined }- );+const getRefreshedProject = async ({+ projectId,+ showError = true,+ query = () => nativeClient.domain.project.query({ projectId }),+ isCurrent = () => true,+}: {+ projectId: Project["id"];+ showError?: boolean;+ query?: () => ReturnType<typeof nativeClient.domain.project.query>;+ isCurrent?: () => boolean;+}) => {+ if ($project.get()?.id !== projectId || !isCurrent()) {+ return;+ }++ const result = await query();+ if ($project.get()?.id !== projectId || !isCurrent()) {+ return;+ }if (result.success) {$project.set(result.project);- return;+ return result.project;}- toast.error(result.error);+ if (showError) {+ toast.error(result.error);+ }+};++const refreshProject = async () => {+ await getRefreshedProject({ projectId: $project.get()!.id });};const buttonLinkClass = css({@@ -1239,10 +1588,8 @@ const UpgradeBanner = ({ hasCustomDomains }: { hasCustomDomains: boolean }) => {const Content = (props: {projectId: Project["id"];onExportClick: () => void;- validationState: PublishValidationState;- onValidationStateChange: (state: PublishValidationState) => void;- isPublishing: boolean;- setIsPublishing: (isPublishing: boolean) => void;+ validation: ReturnType<typeof usePublishValidationState>;+ progress: ReturnType<typeof usePublishProgress>;}) => {const restrictedFeatures = useStore($restrictedFeatures);const [newDomains, setNewDomains] = useState(new Set<string>());@@ -1315,6 +1662,7 @@ const Content = (props: {refresh={refreshProject}projectState={projectState}project={project}+ validatedDomains={props.progress.manualValidationFindings.domains}/><Domains@@ -1322,6 +1670,7 @@ const Content = (props: {domains={project.domainsVirtual}refresh={refreshProject}project={project}+ validatedDomains={props.progress.manualValidationFindings.domains}/></RadioGroup></ScrollArea>@@ -1358,10 +1707,8 @@ const Content = (props: {timesLeft={maxDailyPublishesPerUser - userPublishCount}disabled={false}restrictedFeatures={restrictedFeatures}- validationState={props.validationState}- onValidationStateChange={props.onValidationStateChange}- isPublishing={props.isPublishing}- setIsPublishing={props.setIsPublishing}+ validation={props.validation}+ progress={props.progress}/></PanelContent></form>@@ -1589,10 +1936,68 @@ type PublishProps = {export const PublishButton = ({ projectId }: PublishProps) => {const publishDialog = useStore($publishDialog);const authTokenPermissions = useStore($authTokenPermissions);- const { validationState, update, reset } = usePublishValidationState(- publishDialog === "publish"- );- const [isPublishing, setIsPublishing] = useOptimistic(false);+ const validation = usePublishValidationState(publishDialog);+ const publishProgress = usePublishProgress(projectId);+ const {+ dismissCountdown,+ reconcileRefreshedProject,+ watchPendingPublish,+ beginPopoverRefresh,+ isRefreshCurrent,+ } = publishProgress;+ useEffect(() => {+ if (publishDialog !== "publish") {+ dismissCountdown();+ }+ }, [publishDialog, dismissCountdown]);+ useEffect(() => {+ // Refresh a build that finished while the popover was closed, including+ // after a publish status request failed.+ if (publishDialog === "publish" && publishProgress.isPublishing === false) {+ let isOpen = true;+ const generation = beginPopoverRefresh();+ void refreshUntilSuccess(+ async (showError) => {+ const refreshedProject = await getRefreshedProject({+ projectId,+ showError,+ isCurrent: () => isOpen && isRefreshCurrent(generation),+ });+ if (+ isOpen &&+ isRefreshCurrent(generation) &&+ refreshedProject !== undefined+ ) {+ reconcileRefreshedProject(refreshedProject);+ }+ return refreshedProject;+ },+ () => isOpen,+ () => {+ void watchPendingPublish(+ () =>+ getRefreshedProject({+ projectId,+ showError: false,+ isCurrent: () => isRefreshCurrent(generation),+ }),+ generation+ );+ }+ );+ return () => {+ isOpen = false;+ };+ }+ }, [+ projectId,+ publishDialog,+ publishProgress.isPublishing,+ reconcileRefreshedProject,+ watchPendingPublish,+ beginPopoverRefresh,+ isRefreshCurrent,+ ]);const { canPublishToStagingOnly } = useStore($permissions);const isPublishEnabled =authTokenPermissions.canPublish || canPublishToStagingOnly;@@ -1601,13 +2006,15 @@ export const PublishButton = ({ projectId }: PublishProps) => {: "Only the owner, an admin, or content editors with publish permissions can publish projects";const handleExportClick = () => {- reset();+ validation.reset();+ publishProgress.dismissCountdown();$publishDialog.set("export");};const handleOpenChange = (isOpen: boolean) => {if (isOpen === false) {- reset();+ validation.reset();+ publishProgress.dismissCountdown();}$publishDialog.set(isOpen ? "publish" : "none");};@@ -1648,10 +2055,8 @@ export const PublishButton = ({ projectId }: PublishProps) => {<ContentprojectId={projectId}onExportClick={handleExportClick}- validationState={validationState}- onValidationStateChange={update}- isPublishing={isPublishing}- setIsPublishing={setIsPublishing}+ validation={validation}+ progress={publishProgress}/>)}</PopoverContent>@@ -1659,4 +2064,11 @@ export const PublishButton = ({ projectId }: PublishProps) => {);};-undefined;+export const __testing__ = {+ usePublishProgress,+ useManualValidationFindings,+ waitForPublishStatus,+ refreshUntilSuccess,+ getRefreshedProject,+ reportPublishResult,+};diff --git a/docs/university/foundations/publishing-and-custom-domains.md b/docs/university/foundations/publishing-and-custom-domains.mdindex 178d8c128c..3908587b89 100644--- a/docs/university/foundations/publishing-and-custom-domains.md+++ b/docs/university/foundations/publishing-and-custom-domains.md@@ -78,7 +78,8 @@ Verification may take up to 24 hours but usually takes only a few minutes.You must publish your site _after_ the domain is verified, or else "[Worker not found](publishing-and-custom-domains.md#domain-issues)" will show on the site.{% endhint %}-Keep the Publish dialog open to follow the build and deployment status. Resolve any reported error before trying again.+You can close the Publish dialog while the build runs. Reopen it to see the+latest status. Resolve any reported error before trying again.Each domain shows a yellow progress icon while publishing and a green checkmarkonce publishing finishes. A red icon indicates a failure. Hover over the icon