@byline/host-tanstack-start 4.19.0 → 5.0.0

package/dist/admin-shell/collections/tree-list.js

@@ -1,4 +1,6 @@
 import { jsx, jsxs } from "react/jsx-runtime";
+import { DocumentMutationNotice } from "../document-mutation-notice.js";
+import { useDocumentMutationState } from "../document-mutation-state.js";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { useRouter } from "@tanstack/react-router";
 import { StatusBadge, renderFormatted } from "@byline/admin/react";
@@ -55,6 +57,7 @@ function SortableTreeRow({ id, dragging, disabled, dragHandleLabel, children })
     });
 }
 const TreeListView = ({ rows, columns, workflowStatuses, useAsTitle, collection, collectionLabels, onMove, listActions })=>{
+    const mutation = useDocumentMutationState(void 0);
     const { t } = useTranslation('byline-admin');
     const router = useRouter();
     const toastManager = useToastManager();
@@ -66,12 +69,13 @@ const TreeListView = ({ rows, columns, workflowStatuses, useAsTitle, collection,
     const [moveController] = useState(()=>createAdminTreeMoveController());
     const preserveOptimisticForRows = useRef(null);
     useEffect(()=>{
-        if (!shouldSyncAdminTreeRows(rows, preserveOptimisticForRows.current, isMoving)) return;
+        if (mutation.blocked || !shouldSyncAdminTreeRows(rows, preserveOptimisticForRows.current, isMoving)) return;
         preserveOptimisticForRows.current = null;
         setLocalPlaced(rows.filter((r)=>!r.unplaced));
     }, [
         rows,
-        isMoving
+        isMoving,
+        mutation.blocked
     ]);
     const [activeId, setActiveId] = useState(null);
     const [overId, setOverId] = useState(null);
@@ -98,12 +102,12 @@ const TreeListView = ({ rows, columns, workflowStatuses, useAsTitle, collection,
         setOffsetLeft(0);
     };
     const handleDragStart = ({ active })=>{
-        if (!moveController.isMoving()) setActiveId(String(active.id));
+        if (!mutation.blocked && !moveController.isMoving()) setActiveId(String(active.id));
     };
     const handleDragMove = ({ delta })=>setOffsetLeft(delta.x);
     const handleDragOver = ({ over })=>setOverId(over ? String(over.id) : null);
     const handleDragEnd = async ({ active, over })=>{
-        if (moveController.isMoving()) return void resetDnd();
+        if (mutation.blocked || moveController.isMoving()) return void resetDnd();
         const proj = null != over ? getTreeProjection(localPlaced, String(active.id), String(over.id), offsetLeft, INDENT) : null;
         resetDnd();
         if (!onMove || null == proj) return;
@@ -125,9 +129,11 @@ const TreeListView = ({ rows, columns, workflowStatuses, useAsTitle, collection,
             setIsMoving(moveController.isMoving());
             return;
         }
+        if ('receipt' in outcome) mutation.reportStructure(outcome.receipt);
+        const handled = 'error' in outcome ? mutation.report(outcome.error) : null;
         const effects = getAdminTreeMoveUiEffects(outcome);
         if (effects.rollback) setLocalPlaced(current);
-        if (null != effects.structuralFailure) {
+        if (!handled && null != effects.structuralFailure) {
             const conflict = 'conflict' === effects.structuralFailure;
             toastManager.add({
                 title: t(conflict ? 'collections.list.treeConflictToast' : 'collections.list.reorderFailedToast'),
@@ -202,6 +208,10 @@ const TreeListView = ({ rows, columns, workflowStatuses, useAsTitle, collection,
     return /*#__PURE__*/ jsx(Section, {
         children: /*#__PURE__*/ jsxs(Container, {
             children: [
+                /*#__PURE__*/ jsx(DocumentMutationNotice, {
+                    issue: mutation.issue,
+                    scheduleNotice: mutation.scheduleNotice
+                }),
                 /*#__PURE__*/ jsxs("div", {
                     className: clsx('byline-coll-list-head', tree_list_module.head),
                     children: [
@@ -271,7 +281,7 @@ const TreeListView = ({ rows, columns, workflowStatuses, useAsTitle, collection,
                                                 return dndEnabled ? /*#__PURE__*/ jsx(SortableTreeRow, {
                                                     id: row.id,
                                                     dragging: row.id === activeId,
-                                                    disabled: isMoving,
+                                                    disabled: mutation.blocked || isMoving,
                                                     dragHandleLabel: t('collections.list.dragHandleAriaLabel'),
                                                     children: renderCells(row, depth)
                                                 }, row.id) : /*#__PURE__*/ jsx(Table.Row, {

package/dist/admin-shell/collections/version-history.d.ts

@@ -40,6 +40,7 @@ interface VersionHistoryRowContext {
     actionLabel: string;
     restoreStatusLabel: string;
     openCompare: () => void;
+    mutationsBlocked: boolean;
     openRestore: () => void;
 }
 /**
@@ -66,7 +67,7 @@ export declare function VersionHistoryCore({ data, resourceDefinition, resourceP
     rowPresentation: VersionHistoryRowPresentation;
     loadHistoricalVersion: HistoricalVersionLoader;
     onPageSizeChange: (pageSize: number) => void;
-    restoreVersion: (versionId: string) => Promise<unknown>;
+    restoreVersion: (versionId: string, expectedRevision: number) => Promise<unknown>;
     onRestoreComplete: () => void | Promise<void>;
 }): import("react").JSX.Element;
 export {};

package/dist/admin-shell/collections/version-history.js

@@ -1,4 +1,6 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { DocumentMutationNotice } from "../document-mutation-notice.js";
+import { useDocumentMutationState } from "../document-mutation-state.js";
 import { Fragment as external_react_Fragment, Suspense, lazy, useState } from "react";
 import { getDefaultStatus, getWorkflowStatuses } from "@byline/core";
 import { useTranslation } from "@byline/i18n/react";
@@ -33,6 +35,7 @@ function padRows(value) {
         }, `empty-row-${index}`));
 }
 function VersionHistoryCore({ data, resourceDefinition, resourcePath, documentId, currentDocument, locale, rowPresentation, loadHistoricalVersion, onPageSizeChange, restoreVersion, onRestoreComplete }) {
+    const mutation = useDocumentMutationState(currentDocument);
     const { t } = useTranslation('byline-admin');
     const [selectedVersion, setSelectedVersion] = useState(null);
     const [restoreTarget, setRestoreTarget] = useState(null);
@@ -41,6 +44,9 @@ function VersionHistoryCore({ data, resourceDefinition, resourcePath, documentId
     const restoreStatusLabel = getWorkflowStatuses(resourceDefinition).find((status)=>status.name === restoreStatus)?.label ?? restoreStatus;
     return /*#__PURE__*/ jsxs(Fragment, {
         children: [
+            /*#__PURE__*/ jsx(DocumentMutationNotice, {
+                issue: mutation.issue
+            }),
             /*#__PURE__*/ jsx("div", {
                 className: clsx('byline-coll-history-options', history_module.options),
                 children: /*#__PURE__*/ jsx(RouterPager, {
@@ -85,7 +91,7 @@ function VersionHistoryCore({ data, resourceDefinition, resourcePath, documentId
                                         });
                                     };
                                     const openRestore = ()=>{
-                                        if (null == versionId || versionId === currentVersionId) return;
+                                        if (mutation.blocked || null == versionId || versionId === currentVersionId) return;
                                         setRestoreTarget({
                                             versionId,
                                             label: versionLabel,
@@ -119,6 +125,7 @@ function VersionHistoryCore({ data, resourceDefinition, resourcePath, documentId
                                                         actionLabel,
                                                         restoreStatusLabel,
                                                         openCompare,
+                                                        mutationsBlocked: mutation.blocked,
                                                         openRestore
                                                     })
                                                 ]
@@ -243,11 +250,13 @@ function VersionHistoryCore({ data, resourceDefinition, resourcePath, documentId
                             ]
                         }),
                         restoreTarget ? /*#__PURE__*/ jsx(RestoreVersionModal, {
+                            disabled: mutation.blocked,
+                            onMutationError: mutation.report,
                             versionLabel: restoreTarget.label,
                             versionNumber: restoreTarget.versionNumber,
                             restoreStatusLabel: restoreStatusLabel,
                             onClose: ()=>setRestoreTarget(null),
-                            restoreVersion: ()=>restoreVersion(restoreTarget.versionId),
+                            restoreVersion: ()=>restoreVersion(restoreTarget.versionId, mutation.expectedRevision()),
                             onRestoreComplete: onRestoreComplete
                         }) : null
                     ]

package/dist/admin-shell/document-mutation-notice.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentMutationIssue } from './document-mutation-state.js';
+/** Persistent recovery for list, history and schedule views without local form drafts. */
+export declare function DocumentMutationNotice({ issue, scheduleNotice, }: {
+    issue: DocumentMutationIssue | null;
+    scheduleNotice?: boolean;
+}): import("react").JSX.Element | null;

package/dist/admin-shell/document-mutation-notice.js

@@ -0,0 +1,53 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { useTranslation } from "@byline/i18n/react";
+import { Alert, Button } from "@byline/ui/react";
+import { getAdminRoutePath } from "../routes/admin-path.js";
+function DocumentMutationNotice({ issue, scheduleNotice = false }) {
+    const { t } = useTranslation('byline-admin');
+    const warning = useRef(null);
+    useEffect(()=>{
+        if (issue) warning.current?.focus();
+    }, [
+        issue
+    ]);
+    if (!issue && !scheduleNotice) return null;
+    return /*#__PURE__*/ jsxs("div", {
+        ref: warning,
+        tabIndex: -1,
+        role: "alert",
+        "aria-live": "assertive",
+        children: [
+            issue && /*#__PURE__*/ jsxs(Alert, {
+                close: false,
+                intent: "warning",
+                title: t(`documentConcurrency.${issue}Title`),
+                children: [
+                    /*#__PURE__*/ jsx("p", {
+                        children: t(`documentConcurrency.${issue}`)
+                    }),
+                    'committed' !== issue && /*#__PURE__*/ jsx(Button, {
+                        type: "button",
+                        onClick: ()=>window.location.reload(),
+                        children: t('documentConcurrency.reloadAction')
+                    })
+                ]
+            }),
+            scheduleNotice && /*#__PURE__*/ jsxs(Alert, {
+                close: false,
+                intent: "warning",
+                title: t('documentConcurrency.schedulesTitle'),
+                children: [
+                    /*#__PURE__*/ jsx("p", {
+                        children: t('documentConcurrency.schedules')
+                    }),
+                    /*#__PURE__*/ jsx("a", {
+                        href: getAdminRoutePath('scheduled-publications'),
+                        children: t('documentConcurrency.reviewSchedules')
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { DocumentMutationNotice };

package/dist/admin-shell/document-mutation-state.d.ts

@@ -0,0 +1,22 @@
+export type DocumentMutationIssue = 'stale' | 'reload' | 'lock' | 'unavailable' | 'committed';
+/** A rejected observation stays frozen until an explicit editor reload. */
+export declare function useDocumentMutationState<T extends {
+    id?: unknown;
+    versionId?: unknown;
+    revision?: unknown;
+}>(document: T | null | undefined): {
+    issue: DocumentMutationIssue | null;
+    blocked: boolean;
+    scheduleNotice: boolean;
+    document: T | null | undefined;
+    revision: number | undefined;
+    expectedRevision: () => number;
+    assertWritable: () => void;
+    adopt: (receipt: {
+        documentId: string;
+        revision: number;
+        scheduledPublicationsNeedReconfirmation?: boolean;
+    }) => void;
+    report: (error: unknown) => 'blocked' | 'committed' | null;
+    reportStructure: (result: unknown) => void;
+};

package/dist/admin-shell/document-mutation-state.js

@@ -0,0 +1,71 @@
+import { useRef, useState } from "react";
+import { ErrorCodes, getDocumentRevisionValidationDetails, getDocumentStaleDetails, getLockConflictDetails, parseDocumentRevision } from "@byline/core";
+import { getDocumentHookCommittedDetails } from "@byline/core/services";
+import { committedTreeReceipt, structuralReceipt } from "../server-fns/structural-receipt.js";
+function documentMutationIssue(error) {
+    if (getDocumentStaleDetails(error)) return 'stale';
+    if (getDocumentRevisionValidationDetails(error)) return 'reload';
+    if (getLockConflictDetails(error)) return 'lock';
+    if (getDocumentHookCommittedDetails(error) || committedTreeReceipt(error)) return 'committed';
+    if ('object' == typeof error && null !== error && Reflect.get(error, 'code') === ErrorCodes.NOT_FOUND) return 'unavailable';
+    return null;
+}
+function useDocumentMutationState(document) {
+    const [issue, setIssue] = useState(null);
+    const [scheduleNotice, setScheduleNotice] = useState(false);
+    const [, setReceiptRevision] = useState();
+    const blockedError = useRef(void 0);
+    const observation = useRef({
+        identity: document,
+        revision: document?.revision
+    });
+    if (observation.current.identity !== document && void 0 === blockedError.current && document?.revision === observation.current.revision) observation.current = {
+        identity: document,
+        revision: document?.revision
+    };
+    const assertWritable = ()=>{
+        if (void 0 !== blockedError.current) throw blockedError.current;
+    };
+    const expectedRevision = ()=>{
+        assertWritable();
+        return parseDocumentRevision(observation.current.revision);
+    };
+    const adopt = (receipt)=>{
+        if (void 0 !== blockedError.current) return;
+        if (document?.id != null && receipt.documentId !== document.id) return;
+        observation.current.revision = parseDocumentRevision(receipt.revision);
+        setReceiptRevision(receipt.revision);
+        if (receipt.scheduledPublicationsNeedReconfirmation) setScheduleNotice(true);
+    };
+    const reportStructure = (result)=>{
+        const receipt = structuralReceipt(result);
+        if (receipt) adopt(receipt);
+    };
+    const report = (error)=>{
+        const kind = documentMutationIssue(error);
+        if (null === kind) return null;
+        if ('committed' === kind) {
+            if (void 0 !== blockedError.current) return 'blocked';
+            const details = getDocumentHookCommittedDetails(error) ?? committedTreeReceipt(error);
+            if (details) adopt(details);
+            setIssue(kind);
+            return 'committed';
+        }
+        blockedError.current = error;
+        setIssue(kind);
+        return 'blocked';
+    };
+    return {
+        issue,
+        blocked: null !== issue && 'committed' !== issue,
+        scheduleNotice,
+        document: observation.current.identity,
+        revision: 'number' == typeof observation.current.revision ? observation.current.revision : void 0,
+        expectedRevision,
+        assertWritable,
+        adopt,
+        report,
+        reportStructure
+    };
+}
+export { useDocumentMutationState };

package/dist/admin-shell/document-mutation-state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/admin-shell/scheduled-publications/list.js

@@ -1,5 +1,7 @@
 "use client";
 import { jsx, jsxs } from "react/jsx-runtime";
+import { DocumentMutationNotice } from "../document-mutation-notice.js";
+import { useDocumentMutationState } from "../document-mutation-state.js";
 import { useMemo, useState } from "react";
 import { useRouterState } from "@tanstack/react-router";
 import { deriveScheduledPublicationState } from "@byline/admin/react";
@@ -35,6 +37,7 @@ function ScheduledPublicationsView({ data }) {
         select: (state)=>state.location
     });
     const search = location.search;
+    const mutation = useDocumentMutationState(void 0);
     const [cancelling, setCancelling] = useState(null);
     const applySearch = (patch)=>{
         navigate({
@@ -46,13 +49,16 @@ function ScheduledPublicationsView({ data }) {
             }
         });
     };
-    const cancel = async (collection, documentId)=>{
+    const cancel = async (collection, documentId, expectedRevision)=>{
+        if (mutation.blocked || cancelling) return;
         setCancelling(documentId);
         try {
+            mutation.assertWritable();
             const result = await cancelCollectionDocumentScheduledPublish({
                 data: {
                     collection,
-                    id: documentId
+                    id: documentId,
+                    expectedRevision
                 }
             });
             const cancelled = 'cancelled' === result.status;
@@ -71,9 +77,10 @@ function ScheduledPublicationsView({ data }) {
                 search: location.search
             });
         } catch (error) {
+            if (mutation.report(error)) return;
             toastManager.add({
                 title: t('scheduledPublication.toast.failedTitle'),
-                description: error.message,
+                description: t('documentConcurrency.failed'),
                 data: {
                     intent: 'danger',
                     iconType: 'danger',
@@ -89,6 +96,9 @@ function ScheduledPublicationsView({ data }) {
     return /*#__PURE__*/ jsx(Section, {
         children: /*#__PURE__*/ jsxs(Container, {
             children: [
+                /*#__PURE__*/ jsx(DocumentMutationNotice, {
+                    issue: mutation.issue
+                }),
                 /*#__PURE__*/ jsxs("div", {
                     className: clsx('byline-scheduled-list-head', list_module.head),
                     children: [
@@ -264,9 +274,9 @@ function ScheduledPublicationsView({ data }) {
                                                     size: "xs",
                                                     type: "button",
                                                     intent: "danger",
-                                                    disabled: cancelling === schedule.documentId,
+                                                    disabled: mutation.blocked || null !== cancelling,
                                                     "aria-label": t('scheduledPublication.actions.cancel'),
-                                                    onClick: ()=>cancel(schedule.collectionPath, schedule.documentId),
+                                                    onClick: ()=>cancel(schedule.collectionPath, schedule.documentId, schedule.revision),
                                                     children: t('common.actions.cancel')
                                                 })
                                             })

package/dist/admin-shell/singletons/history.js

@@ -53,7 +53,7 @@ function SingletonHistoryView({ singletonDefinition, adminConfig, data, currentD
             ]
         }),
         auditColSpan: 4,
-        renderCells: ({ document, versionId, currentVersionId, actorLabel, restoreStatusLabel, openRestore })=>/*#__PURE__*/ jsxs(Fragment, {
+        renderCells: ({ document, versionId, currentVersionId, actorLabel, restoreStatusLabel, mutationsBlocked, openRestore })=>/*#__PURE__*/ jsxs(Fragment, {
                 children: [
                     /*#__PURE__*/ jsx(Table.Cell, {
                         className: "byline-singleton-history-status-cell",
@@ -77,6 +77,7 @@ function SingletonHistoryView({ singletonDefinition, adminConfig, data, currentD
                             variant: "outlined",
                             size: "xs",
                             intent: "noeffect",
+                            disabled: mutationsBlocked,
                             onClick: openRestore,
                             className: clsx('byline-coll-history-restore-button', history_module.restoreButton),
                             title: t('collections.history.restoreButtonTitle', {
@@ -143,8 +144,9 @@ function SingletonHistoryView({ singletonDefinition, adminConfig, data, currentD
                             return historical;
                         },
                         onPageSizeChange: handlePageSizeChange,
-                        restoreVersion: (versionId)=>restoreSingletonVersion({
+                        restoreVersion: (versionId, expectedRevision)=>restoreSingletonVersion({
                                 data: {
+                                    expectedRevision,
                                     singleton,
                                     versionId
                                 }

package/dist/admin-shell/singletons/view.d.ts

@@ -5,7 +5,7 @@ type SingletonDocument = Record<string, any> & {
     status: string;
     fields: Record<string, any>;
 };
-export declare function SingletonView({ singletonDefinition, adminConfig, document, initialData, locale, contentLocales, defaultContentLocale, }: {
+export declare function SingletonView({ singletonDefinition, adminConfig, document: loadedDocument, initialData, locale, contentLocales, defaultContentLocale, }: {
     singletonDefinition: SingletonDefinition;
     adminConfig?: SingletonAdminConfig;
     document: SingletonDocument | null;