@umbraco-cms/backoffice 18.0.1 → 18.1.0-rc

package/dist-cms/packages/documents/documents/publishing/repository/document-publishing.server.data-source.js

@@ -1,4 +1,5 @@
 import { UMB_DOCUMENT_ENTITY_TYPE } from '../../entity.js';
+import { umbMapDocumentCreateRequestBody, umbMapDocumentUpdateRequestBody, } from '../../repository/detail/document-detail-request.mappers.js';
 import { DocumentService } from '../../../../core/backend-api/index.js';
 import { tryExecute } from '../../../../core/resources/index.js';
 /**
@@ -16,6 +17,56 @@ export class UmbDocumentPublishingServerDataSource {
     constructor(host) {
         this.#host = host;
     }
+    /**
+     * Creates and publishes a new Document on the server in a single operation
+     * @param {UmbDocumentDetailModel} model - Document Model
+     * @param {Array<UmbVariantId>} variantIds - The variants to publish after creating
+     * @param {string | null} parentUnique - The unique of the parent to create under
+     * @returns {*}
+     * @memberof UmbDocumentPublishingServerDataSource
+     */
+    async createAndPublish(model, variantIds, parentUnique = null) {
+        if (!model)
+            throw new Error('Document is missing');
+        if (!model.unique)
+            throw new Error('Document unique is missing');
+        const body = {
+            ...umbMapDocumentCreateRequestBody(model, parentUnique),
+            culturesToPublish: this.#mapCulturesToPublish(variantIds),
+        };
+        // 201 Created returns only the key (no document body). The workspace reloads after this to refresh
+        // its state, so we deliberately do NOT re-read the full document here — that would be a redundant
+        // round-trip on top of the reload.
+        return tryExecute(this.#host, DocumentService.postDocumentCreateAndPublish({ body }));
+    }
+    /**
+     * Updates and publishes a Document on the server in a single operation
+     * @param {UmbDocumentDetailModel} model - Document Model
+     * @param {Array<UmbVariantId>} variantIds - The variants to publish after updating
+     * @returns {*}
+     * @memberof UmbDocumentPublishingServerDataSource
+     */
+    async updateAndPublish(model, variantIds) {
+        if (!model.unique)
+            throw new Error('Unique is missing');
+        const body = {
+            ...umbMapDocumentUpdateRequestBody(model),
+            culturesToPublish: this.#mapCulturesToPublish(variantIds),
+        };
+        // 200 returns only a notification header (no document body). The workspace reloads after this to
+        // refresh its state, so we deliberately do NOT re-read the full document here.
+        return tryExecute(this.#host, DocumentService.putDocumentByIdUpdateAndPublish({ path: { id: model.unique }, body }));
+    }
+    /**
+     * Maps the selected variants to the culture codes accepted by the create/update-and-publish endpoints.
+     * Invariant content types require an empty array (cultures cannot be specified), and the server rejects
+     * `null`/`"*"` entries, so invariant variants are filtered out and only distinct culture codes remain.
+     * @param {Array<UmbVariantId>} variantIds - The selected variants to publish
+     * @returns {Array<string>} The distinct culture codes to publish
+     */
+    #mapCulturesToPublish(variantIds) {
+        return [...new Set(variantIds.filter((x) => !x.isCultureInvariant()).map((x) => x.toCultureString()))];
+    }
     /**
      * Publish one or more variants of a Document
      * @param {string} unique

package/dist-cms/packages/documents/documents/publishing/unpublish/entity-action/constants.d.ts

@@ -0,0 +1,2 @@
+import type { MetaEntityActionContentUnpublishKind } from '../../../../../content/content/index.js';
+export declare const UmbDocumentUnpublishManifestEntityActionMeta: MetaEntityActionContentUnpublishKind;

package/dist-cms/packages/documents/documents/publishing/unpublish/entity-action/constants.js

@@ -0,0 +1,15 @@
+import { UMB_DOCUMENT_CONFIGURATION_REPOSITORY_ALIAS } from '../../../configuration/constants.js';
+import { UMB_DOCUMENT_DETAIL_REPOSITORY_ALIAS } from '../../../repository/index.js';
+import { UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS, UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS } from '../../../constants.js';
+import { UMB_DOCUMENT_PUBLISHING_REPOSITORY_ALIAS } from '../../repository/constants.js';
+export const UmbDocumentUnpublishManifestEntityActionMeta = {
+    icon: 'icon-globe',
+    label: '#actions_unpublish',
+    additionalOptions: true,
+    detailRepositoryAlias: UMB_DOCUMENT_DETAIL_REPOSITORY_ALIAS,
+    publishingRepositoryAlias: UMB_DOCUMENT_PUBLISHING_REPOSITORY_ALIAS,
+    itemRepositoryAlias: UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS,
+    referenceRepositoryAlias: UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS,
+    configurationRepositoryAlias: UMB_DOCUMENT_CONFIGURATION_REPOSITORY_ALIAS,
+    unpublishedNotificationMessage: '#speechBubbles_editContentUnpublishedHeader',
+};

package/dist-cms/packages/documents/documents/publishing/unpublish/entity-action/index.d.ts

@@ -1 +1 @@
-export * from './unpublish.action.js';
+export * from './constants.js';

package/dist-cms/packages/documents/documents/publishing/unpublish/entity-action/index.js

@@ -1 +1 @@
-export * from './unpublish.action.js';
+export * from './constants.js';

package/dist-cms/packages/documents/documents/publishing/unpublish/entity-action/manifests.js

@@ -1,20 +1,16 @@
 import { UMB_DOCUMENT_ENTITY_TYPE } from '../../../entity.js';
 import { UMB_USER_PERMISSION_DOCUMENT_UNPUBLISH } from '../../../user-permissions/document/constants.js';
+import { UmbDocumentUnpublishManifestEntityActionMeta } from './constants.js';
 import { UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS } from '../../../../../core/recycle-bin/index.js';
 export const manifests = [
     {
         type: 'entityAction',
-        kind: 'default',
+        kind: 'contentUnpublish',
         alias: 'Umb.EntityAction.Document.Unpublish',
         name: 'Unpublish Document Entity Action',
         weight: 500,
-        api: () => import('./unpublish.action.js'),
         forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
-        meta: {
-            icon: 'icon-globe',
-            label: '#actions_unpublish',
-            additionalOptions: true,
-        },
+        meta: UmbDocumentUnpublishManifestEntityActionMeta,
         conditions: [
             {
                 alias: 'Umb.Condition.UserPermission.Document',

package/dist-cms/packages/documents/documents/publishing/unpublish/entity-bulk-action/unpublish.bulk-action.js

@@ -1,8 +1,11 @@
-import { UmbUnpublishDocumentEntityAction } from '../entity-action/index.js';
-import { UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_UNPUBLISH_MODAL } from '../../../constants.js';
+var _a;
+import { UmbDocumentUnpublishManifestEntityActionMeta } from '../entity-action/constants.js';
+import { UMB_DOCUMENT_ENTITY_TYPE } from '../../../constants.js';
 import { UmbDocumentPublishingRepository } from '../../repository/index.js';
 import { UmbDocumentPublishEntityBulkAction } from '../../publish/entity-bulk-action/publish.bulk-action.js';
 import { UmbDocumentItemRepository } from '../../../item/repository/index.js';
+import { UMB_CONTENT_UNPUBLISH_MODAL, UmbContentUnpublishEntityAction } from '../../../../../content/content/index.js';
+import { html, nothing } from '../../../../../../external/lit/index.js';
 import { umbConfirmModal, umbOpenModal } from '../../../../../core/modal/index.js';
 import { UmbEntityBulkActionBase } from '../../../../../core/entity-bulk-action/index.js';
 import { UmbLanguageCollectionRepository } from '../../../../../language/index.js';
@@ -15,83 +18,100 @@ import { UMB_NOTIFICATION_CONTEXT } from '../../../../../core/notification/index
 export class UmbDocumentUnpublishEntityBulkAction extends UmbEntityBulkActionBase {
     async execute() {
         const entityContext = await this.getContext(UMB_ENTITY_CONTEXT);
-        if (!entityContext) {
+        if (!entityContext)
             throw new Error('Entity context not found');
-        }
         const entityType = entityContext.getEntityType();
         const unique = entityContext.getUnique();
-        const localize = new UmbLocalizationController(this);
         if (!entityType)
             throw new Error('Entity type not found');
         if (unique === undefined)
             throw new Error('Entity unique not found');
         // If there is only one selection, we can refer to the regular unpublish entity action:
         if (this.selection.length === 1) {
-            const action = new UmbUnpublishDocumentEntityAction(this._host, {
-                unique: this.selection[0],
-                entityType: UMB_DOCUMENT_ENTITY_TYPE,
-                meta: {},
-            });
-            await action.execute();
-            return;
+            return this.#unpublishSingleSelection();
         }
+        return this.#unpublishMultipleSelections(entityType, unique);
+    }
+    async #unpublishSingleSelection() {
+        const action = new UmbContentUnpublishEntityAction(this._host, {
+            unique: this.selection[0],
+            entityType: UMB_DOCUMENT_ENTITY_TYPE,
+            meta: UmbDocumentUnpublishManifestEntityActionMeta,
+        });
+        await action.execute();
+    }
+    async #unpublishMultipleSelections(entityType, unique) {
         // Fetch document items and languages in parallel
         const itemRepository = new UmbDocumentItemRepository(this._host);
         const languageRepository = new UmbLanguageCollectionRepository(this._host);
         const [{ data: documentItems }, { data: languageData }] = await Promise.all([
             itemRepository.requestItems(this.selection),
-            languageRepository.requestCollection({}),
+            languageRepository.requestAllItems(),
         ]);
         if (!documentItems?.length)
             return;
         const { allInvariant, options } = UmbDocumentPublishEntityBulkAction.buildVariantOptions(documentItems, languageData?.items ?? []);
         // If there is only one language available, or all selected documents are invariant, we can skip the modal and unpublish directly:
         if (options.length === 1 || allInvariant) {
-            const confirm = await umbConfirmModal(this, {
-                headline: '#actions_unpublish',
-                content: '#prompt_confirmListViewUnpublish',
-                color: 'warning',
-                confirmLabel: '#actions_unpublish',
-            }).catch(() => false);
-            if (confirm !== false) {
-                // For invariant documents, use null culture; otherwise use the first language
-                const variantId = allInvariant
-                    ? UmbVariantId.CreateInvariant()
-                    : new UmbVariantId(options[0].language.unique, null);
-                const documentCnt = await this.#unpublishDocuments(this.selection, [variantId]);
-                const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
-                notificationContext?.peek('positive', {
-                    data: {
-                        headline: localize.term('speechBubbles_contentUnpublished'),
-                        message: localize.term('speechBubbles_editMultiContentUnpublishedText', documentCnt),
-                    },
-                });
-                await this.#reloadChildren(entityType, unique);
-            }
-            return;
+            return this.#unpublishSingleVariant(entityType, unique, options, allInvariant);
         }
+        return this.#unpublishSelectedVariants(entityType, unique, options);
+    }
+    async #unpublishSingleVariant(entityType, unique, options, allInvariant) {
+        const confirm = await umbConfirmModal(this, {
+            headline: '#actions_unpublish',
+            content: '#prompt_confirmListViewUnpublish',
+            color: 'warning',
+            confirmLabel: '#actions_unpublish',
+        }).catch(() => false);
+        if (confirm === false)
+            return;
+        // For invariant documents, use null culture; otherwise use the first language
+        const variantId = allInvariant
+            ? UmbVariantId.CreateInvariant()
+            : new UmbVariantId(options[0].language.unique, null);
+        const documentCnt = await this.#unpublishDocuments(this.selection, [variantId]);
+        const localize = new UmbLocalizationController(this);
+        const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+        notificationContext?.peek('positive', {
+            data: {
+                headline: localize.term('speechBubbles_contentUnpublished'),
+                message: localize.term('speechBubbles_editMultiContentUnpublishedText', documentCnt),
+            },
+        });
+        await this.#reloadChildren(entityType, unique);
+    }
+    async #unpublishSelectedVariants(entityType, unique, options) {
         // Pre-select all cultures from the selected documents
         const selection = options.map((o) => o.unique);
-        const result = await umbOpenModal(this, UMB_DOCUMENT_UNPUBLISH_MODAL, {
+        const result = await umbOpenModal(this, UMB_CONTENT_UNPUBLISH_MODAL, {
             data: {
                 options,
+                renderAdditionalLabel: _a.#renderDocumentCountLabel,
             },
             value: { selection },
         }).catch(() => undefined);
-        if (!result?.selection.length)
-            return;
         const variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
-        if (variantIds.length) {
-            const documentCnt = await this.#unpublishDocuments(this.selection, variantIds);
-            const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
-            notificationContext?.peek('positive', {
-                data: {
-                    headline: localize.term('speechBubbles_contentUnpublished'),
-                    message: localize.term('speechBubbles_editMultiVariantUnpublishedText', documentCnt, localize.list(variantIds.map((v) => v.culture ?? ''))),
-                },
-            });
-            await this.#reloadChildren(entityType, unique);
-        }
+        if (!variantIds.length)
+            return;
+        const documentCnt = await this.#unpublishDocuments(this.selection, variantIds);
+        const localize = new UmbLocalizationController(this);
+        const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+        notificationContext?.peek('positive', {
+            data: {
+                headline: localize.term('speechBubbles_contentUnpublished'),
+                message: localize.term('speechBubbles_editMultiVariantUnpublishedText', documentCnt, localize.list(variantIds.map((v) => v.culture ?? ''))),
+            },
+        });
+        await this.#reloadChildren(entityType, unique);
+    }
+    static #renderDocumentCountLabel(option) {
+        const documentCount = option.documentCount;
+        return documentCount !== undefined
+            ? html `<div class="label-status">
+					<umb-localize key="general_documentCount" .args=${[documentCount]}> ${documentCount} documents </umb-localize>
+				</div>`
+            : nothing;
     }
     async #unpublishDocuments(uniques, variantIds) {
         const repository = new UmbDocumentPublishingRepository(this._host);
@@ -111,4 +131,5 @@ export class UmbDocumentUnpublishEntityBulkAction extends UmbEntityBulkActionBas
         eventContext.dispatchEvent(event);
     }
 }
+_a = UmbDocumentUnpublishEntityBulkAction;
 export { UmbDocumentUnpublishEntityBulkAction as api };

package/dist-cms/packages/documents/documents/publishing/unpublish/modal/document-unpublish-modal.element.d.ts

@@ -9,9 +9,11 @@ import '../../../modals/shared/document-variant-language-picker.element.js';
  * @returns {boolean} boolean
  */
 export declare function isPublished(option: UmbDocumentVariantOptionModel): boolean;
+/** @deprecated Use `umb-content-unpublish-modal` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19. */
 export declare class UmbDocumentUnpublishModalElement extends UmbModalBaseElement<UmbDocumentUnpublishModalData, UmbDocumentUnpublishModalValue> {
     #private;
     protected readonly _selectionManager: UmbSelectionManager<string>;
+    constructor();
     private _options;
     private _selection;
     private _canUnpublish;

package/dist-cms/packages/documents/documents/publishing/unpublish/modal/document-unpublish-modal.element.js

@@ -10,7 +10,7 @@ import { UMB_DOCUMENT_CONFIGURATION_CONTEXT } from '../../../global-contexts/ind
 import { css, customElement, html, nothing, state, when } from '../../../../../../external/lit/index.js';
 import { UmbModalBaseElement } from '../../../../../core/modal/index.js';
 import { UmbTextStyles } from '../../../../../core/style/index.js';
-import { UmbSelectionManager } from '../../../../../core/utils/index.js';
+import { UmbDeprecation, UmbSelectionManager } from '../../../../../core/utils/index.js';
 import '../../../modals/shared/document-variant-language-picker.element.js';
 /**
  * @function isPublished
@@ -21,9 +21,10 @@ export function isPublished(option) {
     return (option.variant?.state === UmbDocumentVariantState.PUBLISHED ||
         option.variant?.state === UmbDocumentVariantState.PUBLISHED_PENDING_CHANGES);
 }
+/** @deprecated Use `umb-content-unpublish-modal` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19. */
 let UmbDocumentUnpublishModalElement = class UmbDocumentUnpublishModalElement extends UmbModalBaseElement {
     constructor() {
-        super(...arguments);
+        super();
         this._selectionManager = new UmbSelectionManager(this);
         this._options = [];
         this._selection = [];
@@ -39,6 +40,11 @@ let UmbDocumentUnpublishModalElement = class UmbDocumentUnpublishModalElement ex
         this._requiredFilter = (variantOption) => {
             return variantOption.language.isMandatory && !this._selection.includes(variantOption.unique);
         };
+        new UmbDeprecation({
+            deprecated: 'UmbDocumentUnpublishModalElement is deprecated.',
+            removeInVersion: '19.0.0',
+            solution: 'Use umb-content-unpublish-modal from @umbraco-cms/backoffice/content instead.',
+        }).warn();
     }
     #pickableFilter;
     firstUpdated() {
@@ -142,16 +148,6 @@ let UmbDocumentUnpublishModalElement = class UmbDocumentUnpublishModalElement ex
 				min-width: 600px;
 				max-width: 90vw;
 			}
-
-			#references {
-				--uui-table-cell-padding: 0;
-			}
-
-			#references-warning {
-				margin-top: 1rem;
-				background-color: var(--uui-color-danger);
-				color: var(--uui-color-danger-contrast);
-			}
 		`,
     ]; }
 };

package/dist-cms/packages/documents/documents/publishing/unpublish/modal/document-unpublish-modal.token.d.ts

@@ -1,9 +1,18 @@
 import type { UmbDocumentVariantPickerData, UmbDocumentVariantPickerValue } from '../../../modals/types.js';
 import { UmbModalToken } from '../../../../../core/modal/index.js';
+/**
+ * @deprecated No longer used internally. Use `UMB_CONTENT_UNPUBLISH_MODAL_ALIAS` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19.
+ * No runtime warning is emitted here: this constant's module is reachable via the public `@umbraco-cms/backoffice/document` barrel, so importing the
+ * package for any reason would evaluate this module and fire a false-positive warning. `UmbDocumentUnpublishModalElement`'s constructor warns accurately instead,
+ * since it only runs when the deprecated modal is genuinely opened.
+ */
 export declare const UMB_DOCUMENT_UNPUBLISH_MODAL_ALIAS = "Umb.Modal.DocumentUnpublish";
+/** @deprecated Use `UmbContentUnpublishModalData` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19. */
 export interface UmbDocumentUnpublishModalData extends UmbDocumentVariantPickerData {
     documentUnique?: string;
 }
+/** @deprecated Use `UmbContentUnpublishModalValue` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19. */
 export interface UmbDocumentUnpublishModalValue extends UmbDocumentVariantPickerValue {
 }
+/** @deprecated No longer used internally. Use `UMB_CONTENT_UNPUBLISH_MODAL` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19. */
 export declare const UMB_DOCUMENT_UNPUBLISH_MODAL: UmbModalToken<UmbDocumentUnpublishModalData, UmbDocumentUnpublishModalValue>;

package/dist-cms/packages/documents/documents/publishing/unpublish/modal/document-unpublish-modal.token.js

@@ -1,5 +1,12 @@
 import { UmbModalToken } from '../../../../../core/modal/index.js';
+/**
+ * @deprecated No longer used internally. Use `UMB_CONTENT_UNPUBLISH_MODAL_ALIAS` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19.
+ * No runtime warning is emitted here: this constant's module is reachable via the public `@umbraco-cms/backoffice/document` barrel, so importing the
+ * package for any reason would evaluate this module and fire a false-positive warning. `UmbDocumentUnpublishModalElement`'s constructor warns accurately instead,
+ * since it only runs when the deprecated modal is genuinely opened.
+ */
 export const UMB_DOCUMENT_UNPUBLISH_MODAL_ALIAS = 'Umb.Modal.DocumentUnpublish';
+/** @deprecated No longer used internally. Use `UMB_CONTENT_UNPUBLISH_MODAL` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 19. */
 export const UMB_DOCUMENT_UNPUBLISH_MODAL = new UmbModalToken(UMB_DOCUMENT_UNPUBLISH_MODAL_ALIAS, {
     modal: {
         type: 'dialog',

package/dist-cms/packages/documents/documents/publishing/workspace-context/document-publishing.workspace-context.js

@@ -1,17 +1,17 @@
 import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from '../../workspace/context/document-workspace.context-token.js';
 import { UmbDocumentPublishingRepository } from '../repository/index.js';
 import { UmbDocumentPublishedPendingChangesManager } from '../pending-changes/index.js';
-import { UmbDocumentVariantState } from '../../variant-state.js';
 import { UMB_DOCUMENT_SCHEDULE_MODAL } from '../schedule-publish/constants.js';
 import { UMB_DOCUMENT_PUBLISH_WITH_DESCENDANTS_MODAL } from '../publish-with-descendants/constants.js';
-import { UMB_DOCUMENT_PUBLISH_MODAL } from '../publish/constants.js';
-import { UmbUnpublishDocumentEntityAction } from '../unpublish/index.js';
+import { UmbDocumentUnpublishManifestEntityActionMeta } from '../unpublish/entity-action/constants.js';
 import { UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_WORKSPACE_ALIAS } from '../../constants.js';
 import { UMB_DOCUMENT_PUBLISHING_WORKSPACE_CONTEXT } from './document-publishing.workspace-context.token.js';
 import { UMB_DOCUMENT_PUBLISHING_SHORTCUT_UNIQUE } from './constants.js';
+import { UmbDocumentVariantState } from '../../variant-state.js';
 import { firstValueFrom } from '../../../../../external/rxjs/index.js';
 import { observeMultiple } from '../../../../../libs/observable-api/index.js';
 import { umbOpenModal } from '../../../../core/modal/index.js';
+import { UMB_CONTENT_PUBLISH_MODAL, UmbContentUnpublishEntityAction } from '../../../../content/content/index.js';
 import { UmbContextBase } from '../../../../../libs/class-api/index.js';
 import { UmbLocalizationController } from '../../../../../libs/localization-api/index.js';
 import { UmbRequestReloadChildrenOfEntityEvent, UmbRequestReloadStructureForEntityEvent, } from '../../../../core/entity-action/index.js';
@@ -146,27 +146,40 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             return;
         const variantIds = variants.map((x) => x.variantId);
         const saveData = await this.#documentWorkspaceContext.constructSaveData(variantIds);
-        await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData);
+        await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#documentWorkspaceContext.askServerToValidate(saveData, variantIds);
         return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, async () => {
-            if (!this.#documentWorkspaceContext) {
-                throw new Error('Document workspace context is missing');
+            try {
+                if (!this.#documentWorkspaceContext) {
+                    throw new Error('Document workspace context is missing');
+                }
+                // Save the document before scheduling
+                await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
+                // Schedule the document
+                const { error } = await this.#publishingRepository.publish(unique, variants);
+                if (error) {
+                    throw error;
+                }
+                const notification = {
+                    data: { message: this.#localize.term('speechBubbles_editContentScheduledSavedText') },
+                };
+                this.#notificationContext?.peek('positive', notification);
+                // reload the document so all states are updated after the publish operation
+                // TODO: It seems wrong to make a full reload, In this case I think we can just update the variants status? [NL]
+                await this.#documentWorkspaceContext.reload();
+                this.#loadAndProcessLastPublished();
+                // request reload of this entity
+                const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
+                this.#eventContext?.dispatchEvent(structureEvent);
             }
-            // Save the document before scheduling
-            await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
-            // Schedule the document
-            const { error } = await this.#publishingRepository.publish(unique, variants);
-            if (error) {
+            catch (error) {
+                // Notify only on the publish path. The validation-failure path below already
+                // notifies, so a shared top-level .catch would fire a second toast. [JOV]
+                this.#notificationContext?.peek('danger', {
+                    data: { message: this.#localize.term('speechBubbles_editContentScheduledNotSavedText') },
+                });
                 return Promise.reject(error);
             }
-            const notification = { data: { message: this.#localize.term('speechBubbles_editContentScheduledSavedText') } };
-            this.#notificationContext?.peek('positive', notification);
-            // reload the document so all states are updated after the publish operation
-            await this.#documentWorkspaceContext.reload();
-            this.#loadAndProcessLastPublished();
-            // request reload of this entity
-            const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
-            this.#eventContext?.dispatchEvent(structureEvent);
         }, async (reason) => {
             const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
             if (!notificationContext) {
@@ -243,6 +256,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                 },
             });
             // reload the document so all states are updated after the publish operation
+            // TODO: It seems wrong to make a full reload, I think we should only load the selected variants. [NL]
             await this.#documentWorkspaceContext.reload();
             await this.#loadAndProcessLastPublished();
             // request reload of this entity
@@ -268,9 +282,16 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const entityType = this.#documentWorkspaceContext.getEntityType();
         if (!entityType)
             throw new Error('Entity type is missing');
-        // TODO: remove meta
-        await new UmbUnpublishDocumentEntityAction(this, { unique, entityType, meta: {} }).execute();
+        const action = new UmbContentUnpublishEntityAction(this, {
+            unique,
+            entityType,
+            meta: UmbDocumentUnpublishManifestEntityActionMeta,
+        });
+        const didUnpublish = await action.executeWithResult();
+        if (!didUnpublish)
+            return;
         // Reload workspace data to reflect the unpublished state
+        // TODO: It seems wrong to make a full reload, In this case I think we can just update the variants status? [NL]
         await this.#documentWorkspaceContext.reload();
         await this.#loadAndProcessLastPublished();
     }
@@ -293,11 +314,13 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         }
         else {
             // If there are multiple variants, we will open the modal to let the user pick which variants to publish.
-            const result = await umbOpenModal(this, UMB_DOCUMENT_PUBLISH_MODAL, {
+            const result = await umbOpenModal(this, UMB_CONTENT_PUBLISH_MODAL, {
                 data: {
                     headline: this.#localize.term('content_saveAndPublishModalTitle'),
                     options,
-                    pickableFilter: this.#publishableVariantsFilter,
+                    // The shared modal's pickableFilter is typed against the generic UmbEntityVariantOptionModel, but
+                    // #determineVariantOptions() (which supplies `options` above) only ever returns document variants here.
+                    pickableFilter: (option) => this.#publishableVariantsFilter(option),
                 },
                 value: { selection: selected },
             }).catch(() => undefined);
@@ -310,18 +333,21 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const saveData = await this.#documentWorkspaceContext.constructSaveData(variantIds);
         await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#documentWorkspaceContext.askServerToValidate(saveData, variantIds);
-        return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, async () => {
-            return this.#performSaveAndPublish(variantIds, saveData);
+        return this.#documentWorkspaceContext.validateVariantsAndSubmit(variantIds, () => {
+            // Notify only on the publish path. The validation-failure path below already
+            // notifies, so a shared top-level .catch would fire a second, contradictory toast. [JOV]
+            return this.#performSaveAndPublish(variantIds, saveData).catch((error) => {
+                this.#notificationContext?.peek('danger', {
+                    data: { message: this.#localize.term('speechBubbles_editContentPublishedFailed') },
+                });
+                return Promise.reject(error);
+            });
         }, async (reason) => {
             // If data of the selection is not valid Then just save:
             await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
             // Notifying that the save was successful, but we did not publish, which is what we want to symbolize here. [NL]
-            const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
-            if (!notificationContext) {
-                throw new Error('Notification context is missing');
-            }
             // TODO: Get rid of the save notification.
-            notificationContext.peek('danger', {
+            this.#notificationContext?.peek('danger', {
                 data: { message: this.#localize.term('speechBubbles_editContentPublishedFailedByValidation') },
             });
             // Reject even thought the save was successful, but we did not publish, which is what we want to symbolize here. [NL]
@@ -338,25 +364,47 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const entityType = this.#documentWorkspaceContext.getEntityType();
         if (!entityType)
             throw new Error('Entity type is missing');
-        await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
-        const { error } = await this.#publishingRepository.publish(unique, variantIds.map((variantId) => ({ variantId })));
-        if (!error) {
-            this.#notificationContext?.peek('positive', {
+        // The publish already succeeded server-side once we reach the read-back; a failed read-back must not be
+        // reported as a publish failure, so we fall back to the submitted data and flag the editor as stale.
+        let reloadAfterPublishFailed = false;
+        const loadAfterPublish = async () => {
+            try {
+                return await this.#documentWorkspaceContext.loadWithoutPersist();
+            }
+            catch {
+                reloadAfterPublishFailed = true;
+                return saveData;
+            }
+        };
+        await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData, {
+            create: async (data, ids, parent) => {
+                const { error } = await this.#publishingRepository.createAndPublish(data, ids, parent.unique);
+                if (error)
+                    throw new Error('Error creating and publishing document', { cause: error });
+                return loadAfterPublish();
+            },
+            update: async (data, ids) => {
+                const { error } = await this.#publishingRepository.updateAndPublish(data, ids);
+                if (error)
+                    throw new Error('Error updating and publishing document', { cause: error });
+                return loadAfterPublish();
+            },
+        });
+        this.#notificationContext?.peek('positive', {
+            data: {
+                message: this.#localize.term('speechBubbles_editContentPublishedHeader'),
+            },
+        });
+        if (reloadAfterPublishFailed) {
+            this.#notificationContext?.peek('warning', {
                 data: {
-                    message: this.#localize.term('speechBubbles_editContentPublishedHeader'),
+                    message: this.#localize.term('speechBubbles_editContentPublishedReloadFailed'),
                 },
             });
-            // Clear stale published data and pending changes state so the
-            // persistedData observer does not run a comparison against outdated
-            // data during reload, which would briefly show a false-positive
-            // "pending changes" state.
-            this.#clear();
-            // reload the document so all states are updated after the publish operation
-            await this.#documentWorkspaceContext.reload();
-            await this.#loadAndProcessLastPublished();
-            const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
-            this.#eventContext?.dispatchEvent(event);
         }
+        await this.#loadAndProcessLastPublished();
+        const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
+        this.#eventContext?.dispatchEvent(event);
     }
     #publishableVariantsFilter;
     async #determineVariantOptions() {

package/dist-cms/packages/documents/documents/recycle-bin/menu/manifests.js

@@ -1,6 +1,6 @@
 import { UMB_CONTENT_MENU_ALIAS } from '../../menu/manifests.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_TREE_ALIAS } from '../constants.js';
-import { UMB_DOCUMENT_WORKSPACE_ALIAS } from '../../constants.js';
+import { UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_DOCUMENT_WORKSPACE_ALIAS, UMB_USER_PERMISSION_DOCUMENT_READ, } from '../../constants.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_MENU_ITEM_ALIAS } from './constants.js';
 import { UMB_ENTITY_IS_TRASHED_CONDITION_ALIAS } from '../../../../core/recycle-bin/index.js';
 import { UMB_WORKSPACE_CONDITION_ALIAS } from '../../../../core/workspace/index.js';
@@ -21,6 +21,10 @@ export const manifests = [
             {
                 alias: 'Umb.Condition.CurrentUser.AllowDocumentRecycleBin',
             },
+            {
+                alias: UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS,
+                allOf: [UMB_USER_PERMISSION_DOCUMENT_READ],
+            },
         ],
     },
     {

package/dist-cms/packages/documents/documents/recycle-bin/root/workspace/manifests.js

@@ -1,3 +1,4 @@
+import { UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS, UMB_USER_PERMISSION_DOCUMENT_READ, } from '../../../user-permissions/constants.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_TREE_ITEM_CHILDREN_COLLECTION_ALIAS } from '../../tree/constants.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE } from '../entity.js';
 import { UMB_DOCUMENT_RECYCLE_BIN_ROOT_WORKSPACE_ALIAS } from './constants.js';
@@ -29,6 +30,10 @@ export const manifests = [
                 alias: UMB_WORKSPACE_CONDITION_ALIAS,
                 match: UMB_DOCUMENT_RECYCLE_BIN_ROOT_WORKSPACE_ALIAS,
             },
+            {
+                alias: UMB_DOCUMENT_USER_PERMISSION_CONDITION_ALIAS,
+                allOf: [UMB_USER_PERMISSION_DOCUMENT_READ],
+            },
         ],
     },
 ];