@delmaredigital/payload-experiments 0.2.0-rc.7 → 0.3.0-rc.4

package/dist/admin/surface/readiness/ActionDialogs.js

@@ -1,8 +1,10 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { DocsResponseError, fetchAllDocs } from '../../../lib/fetchAllDocs.js';
 import { useEffect, useState } from 'react';
-import { Button, TextInput } from '@payloadcms/ui';
-import { DialogFrame } from '../../actions/ConfirmDialog.js';
+import { Button } from '../../../ui/Button.js';
+import { TextInput } from '../../../ui/Inputs.js';
+import { Dialog } from '../../../ui/Dialog.js';
 import { MakeContentResult } from '../../actions/MakeContentResult.js';
 import { expectedConfirm, matchesConfirm } from '../../../transitions/confirmPhrases.js';
 import { ACTIONS_COPY as A } from '../../copy/actions.js';
@@ -15,14 +17,18 @@ import { useTransition } from './useTransition.js';
     const api = createApi(surface.apiRoute);
     const [typed, setTyped] = useState('');
     const [content, setContent] = useState(null);
+    const [reportBusy, setReportBusy] = useState(false);
     const transition = useTransition(test, onClose);
     const phrase = action.confirm.phrase ? expectedConfirm(action.confirm.phrase.action, winnerLabel) : null;
     const ready = action.id !== 'start' || Boolean(test.preflight && !test.preflightPending && !test.preflightError && test.preflight.checks.every((check)=>check.ok));
     const enabled = ready && !transition.busy && !test.hasUnsaved && test.saving !== 'saving' && (!phrase || matchesConfirm(phrase, typed));
-    async function submit() {
+    async function submit(finish = false) {
         if (!enabled || !test.doc) return;
         const id = test.doc.id;
         await transition.run(async ()=>{
+            if (finish) return api.archive(id, {
+                mode: 'after-content'
+            });
             if (action.archive) return api.archive(id, {
                 ...action.archive,
                 ...phrase ? {
@@ -44,22 +50,32 @@ import { useTransition } from './useTransition.js';
                 message: API_MESSAGES.unreadable
             } : result;
         }, {
-            reloadOnSuccess: action.id !== 'make-content'
+            reloadOnSuccess: finish || action.id !== 'make-content'
         });
     }
     function close() {
-        if (transition.busy) return;
+        if (transition.busy || reportBusy) return;
         if (content) void test.reload();
         onClose();
     }
-    return /*#__PURE__*/ _jsxs(DialogFrame, {
+    return /*#__PURE__*/ _jsxs(Dialog, {
+        open: true,
+        initialFocus: action.id === 'start' ? undefined : 'cancel',
+        dismissible: !transition.busy && !reportBusy,
         title: action.confirm.title,
         onClose: close,
         children: [
             content ? /*#__PURE__*/ _jsx(MakeContentResult, {
                 result: content,
-                onRetry: submit,
-                busy: transition.busy
+                id: test.doc?.id,
+                api: api,
+                canManage: surface.canManage,
+                isDecided: (content.doc?.status ?? test.doc?.status) === 'decided',
+                onRetry: ()=>submit(),
+                onFinish: ()=>submit(true),
+                busy: transition.busy,
+                onBusyChange: setReportBusy,
+                onActionStart: transition.clearError
             }) : /*#__PURE__*/ _jsxs(_Fragment, {
                 children: [
                     /*#__PURE__*/ _jsx("p", {
@@ -77,7 +93,7 @@ import { useTransition } from './useTransition.js';
                                 ]
                             }),
                             /*#__PURE__*/ _jsx(TextInput, {
-                                path: "xp-confirmation",
+                                id: "xp-confirmation",
                                 label: A.confirmation,
                                 value: typed,
                                 readOnly: transition.busy,
@@ -99,7 +115,8 @@ import { useTransition } from './useTransition.js';
                 children: action.label
             }) : null,
             /*#__PURE__*/ _jsx(Button, {
-                disabled: transition.busy,
+                "data-dialog-cancel": true,
+                disabled: transition.busy || reportBusy,
                 onClick: close,
                 children: content ? A.done : A.cancel
             })
@@ -113,7 +130,9 @@ import { useTransition } from './useTransition.js';
     const allocation = Number(value);
     const valid = value.trim() !== '' && Number.isInteger(allocation) && allocation > current && allocation <= 100;
     const disabled = transition.busy || test.hasUnsaved || test.saving === 'saving';
-    return /*#__PURE__*/ _jsxs(DialogFrame, {
+    return /*#__PURE__*/ _jsxs(Dialog, {
+        open: true,
+        dismissible: !transition.busy,
         title: C.allocate,
         onClose: ()=>{
             if (!transition.busy) onClose();
@@ -146,8 +165,11 @@ import { useTransition } from './useTransition.js';
             /*#__PURE__*/ _jsx(Button, {
                 disabled: disabled || !valid,
                 onClick: ()=>{
+                    // Not-found can also mean the experiment is missing; use round copy for the missing phase record.
                     if (valid && test.doc) void transition.run(()=>createApi(surface.apiRoute).allocate(test.doc.id, {
                             allocation
+                        }, {
+                            notFound: API_MESSAGES.roundChanged
                         }));
                 },
                 children: C.allocate
@@ -171,16 +193,14 @@ import { useTransition } from './useTransition.js';
         const controller = new AbortController();
         void (async ()=>{
             try {
-                const response = await fetch(`${surface.apiRoute.replace(/\/$/, '')}/xp-metrics?depth=0&limit=100`, {
+                const response = await fetchAllDocs(`${surface.apiRoute.replace(/\/$/, '')}/xp-metrics?depth=0`, {
                     credentials: 'include',
                     signal: controller.signal
                 });
                 if (!response.ok) throw new Error(refusalMessage(undefined, response.status));
-                const data = await response.json();
-                if (!Array.isArray(data.docs)) throw new Error(API_MESSAGES.unreadable);
-                if (!controller.signal.aborted) setMetrics(data.docs);
+                if (!controller.signal.aborted) setMetrics(response.docs);
             } catch (cause) {
-                if (!controller.signal.aborted) setLoadError(cause instanceof Error ? cause.message : API_MESSAGES.network);
+                if (!controller.signal.aborted) setLoadError(cause instanceof DocsResponseError ? API_MESSAGES.unreadable : cause instanceof Error ? cause.message : API_MESSAGES.network);
             } finally{
                 if (!controller.signal.aborted) setLoading(false);
             }
@@ -197,12 +217,17 @@ import { useTransition } from './useTransition.js';
     const available = metrics.filter((item)=>!attached.has(String(item.id)));
     const selected = available.find((item)=>String(item.id) === metric);
     const disabled = transition.busy || test.hasUnsaved || test.saving === 'saving';
-    return /*#__PURE__*/ _jsxs(DialogFrame, {
-        title: C.addMetric,
+    return /*#__PURE__*/ _jsxs(Dialog, {
+        open: true,
+        dismissible: !transition.busy,
+        title: C.addGoal,
         onClose: ()=>{
             if (!transition.busy) onClose();
         },
         children: [
+            /*#__PURE__*/ _jsx("p", {
+                children: C.addMetric
+            }),
             loading ? /*#__PURE__*/ _jsx("p", {
                 role: "status",
                 children: R.loadingMetrics
@@ -257,12 +282,15 @@ import { useTransition } from './useTransition.js';
             /*#__PURE__*/ _jsx(Button, {
                 disabled: disabled || loading || !!loadError || !selected,
                 onClick: ()=>{
+                    // Goal and phase lookups share not-found; prefer the more likely missing goal without reading server text.
                     if (selected && test.doc) void transition.run(()=>createApi(surface.apiRoute).addMetric(test.doc.id, {
                             metric: selected.id,
                             role
+                        }, {
+                            notFound: API_MESSAGES.goalNotFound
                         }));
                 },
-                children: C.addMetric
+                children: C.addGoal
             }),
             /*#__PURE__*/ _jsx(Button, {
                 disabled: transition.busy,

package/dist/admin/surface/readiness/Banner.d.ts

@@ -1,2 +1,5 @@
 import type { SectionProps } from '../contracts.js';
 export declare function Banner(props: SectionProps): import("react").JSX.Element | null;
+export declare function ReadinessContent({ test, surface, resultsVersion, bar }: SectionProps & {
+    bar?: boolean;
+}): import("react").JSX.Element;

package/dist/admin/surface/readiness/Banner.js

@@ -1,12 +1,13 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { theme } from '../../theme.js';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Button } from '@payloadcms/ui';
+import { Button } from '../../../ui/Button.js';
+import { SaveStatus, saveStatusMessage } from './SaveStatus.js';
+import { jumpToSection } from '../test/jumpToSection.js';
 import { actionGroupLabel, availableActions } from '../../actions/actions.model.js';
 import { createApi } from '../../api.js';
 import { READINESS_COPY as C, decidedCopy, nextCopy, runningCopy, stoppedCopy } from '../../copy/readiness.js';
-import { daysRemaining, displayDate, nextStep } from './readiness.model.js';
+import { READINESS, daysRemaining, displayDate, nextStep } from './readiness.model.js';
 import { AddMetricAction, AllocateAction, ConfirmAction } from './ActionDialogs.js';
 import { useTransition } from './useTransition.js';
 const RUNNING_ACTIONS = [
@@ -15,11 +16,11 @@ const RUNNING_ACTIONS = [
     'allocate'
 ];
 export function Banner(props) {
-    return props.test.doc ? /*#__PURE__*/ _jsx(BannerContent, {
+    return props.test.doc ? /*#__PURE__*/ _jsx(ReadinessContent, {
         ...props
     }, `${props.test.doc.id}/${props.test.doc.status}`) : null;
 }
-function BannerContent({ test, surface, resultsVersion }) {
+export function ReadinessContent({ test, surface, resultsVersion, bar = false }) {
     const [selected, setSelected] = useState(null);
     const [people, setPeople] = useState(null);
     const transition = useTransition(test);
@@ -28,10 +29,10 @@ function BannerContent({ test, surface, resultsVersion }) {
         let active = true;
         // The id/status key resets the count; refreshes retain it while loading.
         if (surface.canReadResults && doc.status === 'running') {
-            void createApi(surface.apiRoute).summary([
-                doc.id
-            ]).then((result)=>{
-                if (!result.ok) return;
+            void Promise.resolve().then(()=>active ? createApi(surface.apiRoute).summary([
+                    doc.id
+                ]) : undefined).then((result)=>{
+                if (!result?.ok) return;
                 const count = result.data?.[doc.id]?.exposures;
                 if (active) setPeople(typeof count === 'number' && Number.isFinite(count) ? count : null);
             }).catch(()=>{});
@@ -64,48 +65,72 @@ function BannerContent({ test, surface, resultsVersion }) {
         canManage: surface.canManage
     }).filter((action)=>setup ? action.id === 'start' : doc.status === 'running' ? RUNNING_ACTIONS.includes(action.id) : true).sort((a, b)=>doc.status === 'running' ? RUNNING_ACTIONS.indexOf(a.id) - RUNNING_ACTIONS.indexOf(b.id) : 0).map((action)=>action.id === 'add-metric' ? {
             ...action,
-            label: C.addMetric
+            label: C.addGoal
         } : action.id === 'allocate' ? {
             ...action,
             label: C.allocate
         } : action);
     const action = actions.find((item)=>item.id === selected);
-    const sentence = setup ? ready ? C.ready : next ? nextCopy(next.sentence) : test.preflightError ? C.checkError : C.checking : doc.status === 'running' ? runningCopy(displayDate(doc.startedAt), people, daysRemaining(doc, Date.now())) : doc.status === 'decided' ? decidedCopy(displayDate(doc.decidedAt), winner) : C.archived;
+    const sentence = setup ? bar && test.preflightError ? null : ready ? C.ready : next ? nextCopy(next.sentence) : test.preflightError ? C.checkError : C.checking : doc.status === 'running' ? runningCopy(displayDate(doc.startedAt), people, daysRemaining(doc, Date.now())) : doc.status === 'decided' ? decidedCopy(displayDate(doc.decidedAt), winner) : C.archived;
     return /*#__PURE__*/ _jsxs("div", {
-        className: `xp-readiness xp-readiness--${setup && ready ? 'ready' : 'neutral'}`,
-        style: {
-            padding: '1rem',
-            border: `1px solid ${theme.color.borderStrong}`,
-            borderRadius: theme.radius.small,
-            background: setup && ready ? theme.color.successSurface : theme.color.surface,
-            color: theme.color.text
-        },
+        className: `xp-readiness xp-readiness--${setup && ready ? 'ready' : 'neutral'}${bar ? ' xp-readiness--bar xp-tests-container' : ''}`,
         children: [
-            /*#__PURE__*/ _jsx("p", {
-                role: "status",
-                children: setup && next && !ready && next.section !== 'header' ? /*#__PURE__*/ _jsx("a", {
-                    href: `#section-${next.section}`,
-                    children: sentence
-                }) : sentence
+            /*#__PURE__*/ _jsxs("div", {
+                className: "xp-readiness__state",
+                children: [
+                    bar ? /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsx(SaveStatus, {
+                                test: test
+                            }),
+                            sentence && (saveStatusMessage(test) || test.preflightError) ? /*#__PURE__*/ _jsx("span", {
+                                className: "xp-readiness__separator",
+                                "aria-hidden": "true",
+                                children: "·"
+                            }) : null
+                        ]
+                    }) : null,
+                    sentence ? /*#__PURE__*/ _jsx("p", {
+                        role: "status",
+                        children: setup && next && !ready && next.section !== 'header' ? /*#__PURE__*/ _jsxs("a", {
+                            href: `#section-${next.section}`,
+                            onClick: (event)=>{
+                                event.preventDefault();
+                                if (next.section !== 'header') jumpToSection(next.section);
+                            },
+                            children: [
+                                sentence,
+                                next.nextStep ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                    children: [
+                                        /*#__PURE__*/ _jsx("br", {}),
+                                        /*#__PURE__*/ _jsx("span", {
+                                            children: next.nextStep
+                                        })
+                                    ]
+                                }) : null
+                            ]
+                        }) : sentence
+                    }) : null
+                ]
             }),
+            setup && test.preflight?.checks.some((check)=>check.code === 'page-targets-unchecked' && check.warning) ? /*#__PURE__*/ _jsx("p", {
+                children: C.uncheckedPages
+            }) : null,
+            test.preflight?.checks.filter((check)=>check.code === 'make-content-unsupported' && check.warning).map((check)=>/*#__PURE__*/ _jsx("p", {
+                    children: READINESS[check.code].next(check.detail, doc)
+                }, check.code)),
             doc.status === 'stopped' ? /*#__PURE__*/ _jsx("p", {
                 children: stoppedCopy(displayDate(doc.stoppedAt))
             }) : null,
             /*#__PURE__*/ _jsx("div", {
                 className: "xp-readiness__actions",
-                style: {
-                    display: 'flex',
-                    gap: '0.75rem',
-                    flexWrap: 'wrap',
-                    alignItems: 'center'
-                },
                 children: actions.map((item)=>{
                     const reason = item.id === 'start' ? startReason : unsaved ? C.saveFirst : item.id === 'allocate' && doc.allocation >= 100 ? C.everyone : undefined;
                     const disabled = transition.busy || !!selected || !!reason;
                     return /*#__PURE__*/ _jsx("span", {
                         title: reason,
                         children: /*#__PURE__*/ _jsx(Button, {
-                            buttonStyle: item.tone === 'primary' ? 'primary' : 'secondary',
+                            variant: item.tone === 'primary' || bar && item.id === 'stop' ? 'primary' : 'secondary',
                             disabled: disabled,
                             onClick: ()=>{
                                 if (disabled) return;

package/dist/admin/surface/readiness/SaveStatus.d.ts

@@ -1,4 +1,5 @@
 import type { TestDocApi } from '../contracts.js';
+export declare function saveStatusMessage(test: TestDocApi): string | null;
 export declare function SaveStatus({ test }: {
     test: TestDocApi;
 }): import("react").JSX.Element;

package/dist/admin/surface/readiness/SaveStatus.js

@@ -1,8 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
-import { Button } from '@payloadcms/ui';
+import { Button } from '../../../ui/Button.js';
 import { READINESS_COPY as C } from '../../copy/readiness.js';
+export function saveStatusMessage(test) {
+    return test.saving === 'saving' ? C.saving : test.saving === 'saved' || test.saving === 'idle' ? C.saved : test.saving === 'error' && !test.stale ? C.saveError : null;
+}
 export function SaveStatus({ test }) {
     const inFlight = useRef(false);
     const [retrying, setRetrying] = useState(false);
@@ -17,7 +20,7 @@ export function SaveStatus({ test }) {
             setRetrying(false);
         }
     }
-    const message = test.saving === 'saving' ? C.saving : test.saving === 'saved' ? C.saved : test.saving === 'error' && !test.stale ? C.saveError : null;
+    const message = saveStatusMessage(test);
     return /*#__PURE__*/ _jsxs("div", {
         className: "xp-save-status",
         "aria-live": "polite",
@@ -30,7 +33,7 @@ export function SaveStatus({ test }) {
                 children: [
                     /*#__PURE__*/ _jsx("span", {
                         role: "alert",
-                        children: C.checkError
+                        children: test.preflightError
                     }),
                     ' ',
                     /*#__PURE__*/ _jsx("span", {

package/dist/admin/surface/readiness/readiness.model.d.ts

@@ -9,8 +9,10 @@ export type ReadinessContext = Pick<TestDocument, 'arms' | 'unitType' | 'flagPoi
 export declare const READINESS: Record<ReadinessCode, {
     section: SectionId | 'header';
     next(detail: unknown, ctx: ReadinessContext): string | null;
+    nextStep?: string;
 }>;
 export declare function nextStep(preflight: PreflightResult | null, ctx: ReadinessContext): {
+    nextStep?: string | undefined;
     section: "header" | SectionId;
     sentence: string;
     code: ReadinessCode;

package/dist/admin/surface/readiness/readiness.model.js

@@ -1,5 +1,6 @@
+import { formatDate } from '../../format/date.js';
 import { actionGroupLabel } from '../../actions/actions.model.js';
-import { READINESS_COPY as C, attributeNext, contentNext, goalPeopleNext, parameterNext, placementNext, ruleNext, versionsNext } from '../../copy/readiness.js';
+import { unsupportedContentCopy, versionPageUnavailableCopy, versionPageUncheckedCopy, placementFailureCopy, pageInUseCopy, unpublishedPageCopy, READINESS_COPY as C, attributeNext, contentNext, goalPeopleNext, parameterNext, placementNext, ruleNext, versionsNext } from '../../copy/readiness.js';
 import { SECTION_ORDER } from '../contracts.js';
 const object = (value)=>value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 const first = (value)=>object(Array.isArray(value) ? value[0] : value);
@@ -15,8 +16,9 @@ const row = (section, next)=>({
     });
 const versions = row('versions', (detail)=>versionsNext(detailText(detail, C.versionFallback)));
 /** Exhaustive mapping of the checkStart ReadinessCode union, including all ten invariant checks. */ export const READINESS = {
+    'make-content-unsupported': row('header', (detail)=>unsupportedContentCopy(text(detail, 'This page'))),
     'invalid-status': row('header', ()=>null),
-    'no-placements': row('what', ()=>C.noPlacements),
+    'no-placements': row('what', (detail)=>detail === undefined ? C.noPlacements : placementFailureCopy(detail)),
     'empty-slot': row('versions', (detail, ctx)=>{
         const placements = Array.isArray(detail) ? detail : [];
         const missing = ctx.arms.find((item)=>item.kind !== 'holdout' && placements.some((placement)=>{
@@ -34,6 +36,7 @@ const versions = row('versions', (detail)=>versionsNext(detailText(detail, C.ver
     }),
     'flag-point-busy': row('what', ()=>C.busy),
     'flag-placement-missing': row('versions', (detail, ctx)=>{
+        if (typeof detail === 'string') return placementFailureCopy(detail);
         const value = object(detail);
         const placement = first(value.placements);
         const missing = Array.isArray(value.missing) ? value.missing[0] : undefined;
@@ -46,8 +49,23 @@ const versions = row('versions', (detail)=>versionsNext(detailText(detail, C.ver
     'no-reach-per-day': row('length', ()=>C.noReach),
     'layer-full': row('versions', ()=>C.full),
     'layer-unit-mismatch': row('header', ()=>C.differentPeople),
+    'page-in-use': {
+        ...row('versions', (detail)=>{
+            const paths = object(detail).paths;
+            return pageInUseCopy(text(Array.isArray(paths) ? paths[0] : undefined, 'this page'));
+        }),
+        nextStep: C.chooseDifferentPage
+    },
     'page-no-targets': row('versions', ()=>C.noTargets),
+    'page-target-unpublished': row('versions', (detail)=>unpublishedPageCopy(text(detail, 'This page'))),
+    'page-targets-unchecked': row('versions', ()=>C.uncheckedPages),
+    'version-page-unavailable': row('versions', (detail)=>versionPageUnavailableCopy(text(detail, 'This page'))),
+    'version-page-unchecked': row('versions', (detail)=>versionPageUncheckedCopy(text(detail, 'This page'))),
     'page-user-unit': row('header', ()=>C.pageVisitors),
+    'block-path-rule': {
+        ...row('who', ()=>C.blockPathRule),
+        nextStep: C.removeRule
+    },
     'invalid-targeting-rule': row('who', (detail)=>{
         const attributes = object(detail).attributes;
         return ruleNext(detailText(detail, Array.isArray(attributes) && attributes.length ? attributes.map(String).join(', ') : C.ruleFallback));
@@ -79,7 +97,10 @@ export function nextStep(preflight, ctx) {
             if (sentence) return {
                 section,
                 sentence,
-                code: check.code
+                code: check.code,
+                ...mapping.nextStep ? {
+                    nextStep: mapping.nextStep
+                } : {}
             };
         }
     }
@@ -93,12 +114,7 @@ export function sectionDone(test) {
 }
 export function displayDate(value) {
     if (typeof value !== 'string' || !Number.isFinite(Date.parse(value))) return null;
-    return new Intl.DateTimeFormat('en-US', {
-        year: 'numeric',
-        month: 'short',
-        day: 'numeric',
-        timeZone: 'UTC'
-    }).format(new Date(value));
+    return formatDate(value);
 }
 export function daysRemaining(doc, now) {
     const days = doc.analysis?.plannedDurationDays;

package/dist/admin/surface/readiness/useTransition.d.ts

@@ -7,4 +7,5 @@ export declare function useTransition(test: TestDocApi, onSuccess?: () => void):
     run: (request: () => Promise<ApiResult<unknown>>, { reloadOnSuccess }?: {
         reloadOnSuccess?: boolean | undefined;
     }) => Promise<void>;
+    clearError: () => void;
 };

package/dist/admin/surface/readiness/useTransition.js

@@ -29,6 +29,7 @@ import { API_MESSAGES } from '../../copy/common.js';
     return {
         busy,
         error,
-        run
+        run,
+        clearError: ()=>setError(null)
     };
 }

package/dist/admin/surface/results/ReleasePages.d.ts

@@ -0,0 +1,14 @@
+import type { DocId } from '../../../types/contracts.js';
+import { type PageReleaseDecision } from '../../results/releasePages.model.js';
+export declare function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal }: {
+    id: DocId;
+    apiRoute: string;
+    onClose(): void;
+    onSuccess(): void;
+    onRefusal(message: string): void;
+}): import("react").JSX.Element;
+/** An inaccessible or deleted author never hides the recorded release date. */
+export declare function PagesReleased({ decision, apiRoute }: {
+    decision: PageReleaseDecision;
+    apiRoute: string;
+}): import("react").JSX.Element;

package/dist/admin/surface/results/ReleasePages.js

@@ -0,0 +1,116 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { useAuth, useConfig } from '@payloadcms/ui';
+import { Button } from '../../../ui/Button.js';
+import { Dialog } from '../../../ui/Dialog.js';
+import { createApi } from '../../api.js';
+import { ACTIONS_COPY } from '../../copy/actions.js';
+import { RESULTS_COPY as C, pagesReleasedCopy } from '../../copy/results.js';
+import { formatDate } from '../../format/date.js';
+import { pagesReleasedBy } from '../../results/releasePages.model.js';
+export function ReleasePagesDialog({ id, apiRoute, onClose, onSuccess, onRefusal }) {
+    const [busy, setBusy] = useState(false);
+    const inFlight = useRef(false);
+    const mounted = useRef(true);
+    useEffect(()=>{
+        mounted.current = true;
+        return ()=>{
+            mounted.current = false;
+        };
+    }, []);
+    async function submit() {
+        if (inFlight.current) return;
+        inFlight.current = true;
+        setBusy(true);
+        const result = await createApi(apiRoute).releasePages(id);
+        if (!mounted.current) return;
+        onClose();
+        if (result.ok) onSuccess();
+        else onRefusal(result.message);
+    }
+    return /*#__PURE__*/ _jsxs(Dialog, {
+        open: true,
+        title: C.releasePages,
+        initialFocus: "cancel",
+        dismissible: !busy,
+        onClose: ()=>{
+            if (!inFlight.current) onClose();
+        },
+        children: [
+            /*#__PURE__*/ _jsx("p", {
+                children: C.releasePagesBody
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "xp-ui-button-group",
+                children: [
+                    /*#__PURE__*/ _jsx(Button, {
+                        "data-dialog-cancel": true,
+                        disabled: busy,
+                        onClick: onClose,
+                        children: ACTIONS_COPY.cancel
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        variant: "primary",
+                        busy: busy,
+                        onClick: ()=>{
+                            void submit();
+                        },
+                        children: C.releasePages
+                    })
+                ]
+            })
+        ]
+    });
+}
+/** An inaccessible or deleted author never hides the recorded release date. */ export function PagesReleased({ decision, apiRoute }) {
+    const { user } = useAuth();
+    const { config } = useConfig();
+    const collection = config.admin.user;
+    const by = decision.pagesReleasedBy;
+    const [resolved, setResolved] = useState(null);
+    const key = JSON.stringify([
+        apiRoute,
+        collection,
+        by
+    ]);
+    const own = pagesReleasedBy(by, user?.id);
+    useEffect(()=>{
+        if (!by || own || !collection) return;
+        const controller = new AbortController();
+        const query = new URLSearchParams({
+            depth: '0',
+            'select[name]': 'true',
+            'select[email]': 'true'
+        });
+        void (async ()=>{
+            try {
+                const response = await fetch(`${apiRoute.replace(/\/$/, '')}/${encodeURIComponent(collection)}/${encodeURIComponent(by)}?${query}`, {
+                    method: 'GET',
+                    credentials: 'include',
+                    signal: controller.signal
+                });
+                if (!response.ok) return;
+                const author = await response.json();
+                if (!controller.signal.aborted && author) setResolved({
+                    key,
+                    author: {
+                        name: typeof author.name === 'string' ? author.name : null,
+                        email: typeof author.email === 'string' ? author.email : null
+                    }
+                });
+            } catch  {}
+        })();
+        return ()=>controller.abort();
+    }, [
+        apiRoute,
+        by,
+        collection,
+        key,
+        own
+    ]);
+    const name = own ?? pagesReleasedBy(by, user?.id, resolved?.key === key ? resolved.author : null);
+    return /*#__PURE__*/ _jsx("p", {
+        children: pagesReleasedCopy(formatDate(decision.pagesReleasedAt), name)
+    });
+}

package/dist/admin/surface/results/ResultsBody.d.ts

@@ -1,10 +1,20 @@
 import '../../styles.js';
+import type { ReactNode } from 'react';
 import type { DocId } from '../../../types/contracts.js';
+import type { ResultsResponse } from '../../../types/endpoints.js';
 import type { SurfaceProps } from '../contracts.js';
+export type ResultsPageParts = {
+    children: ReactNode;
+    actions: ReactNode;
+    released: ReactNode;
+    data?: ResultsResponse;
+};
 type ResultsBodyProps = {
+    renderPage?: (parts: ResultsPageParts) => ReactNode;
     id: DocId;
     surface: SurfaceProps;
     onRecomputed?: () => void;
+    onPagesReleased?: () => void;
 };
-export declare function ResultsBody({ id, surface, onRecomputed }: ResultsBodyProps): import("react").JSX.Element;
+export declare function ResultsBody({ id, surface, onRecomputed, onPagesReleased, renderPage }: ResultsBodyProps): import("react").JSX.Element;
 export {};