@umbraco-cms/backoffice 17.6.2 → 17.7.0-rc

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

@@ -1,5 +1,5 @@
 import { UmbDocumentPublishingServerDataSource } from './document-publishing.server.data-source.js';
-import { UmbRepositoryBase } from '../../../../core/repository/index.js';
+import { UmbRepositoryBase, } from '../../../../core/repository/index.js';
 export class UmbDocumentPublishingRepository extends UmbRepositoryBase {
     #publishingDataSource = new UmbDocumentPublishingServerDataSource(this);
     /**
@@ -7,7 +7,7 @@ export class UmbDocumentPublishingRepository extends UmbRepositoryBase {
      * @param {UmbDocumentDetailModel} model - The Document to create
      * @param {Array<UmbVariantId>} variantIds - The variants to publish after creating
      * @param {string | null} parentUnique - The unique of the parent to create under
-     * @returns {*}
+     * @returns {Promise<UmbRepositoryResponse<unknown>>} The result of the create and publish request
      * @memberof UmbDocumentPublishingRepository
      */
     async createAndPublish(model, variantIds, parentUnique = null) {
@@ -21,7 +21,7 @@ export class UmbDocumentPublishingRepository extends UmbRepositoryBase {
      * Updates and publishes an existing Document in a single operation
      * @param {UmbDocumentDetailModel} model - The Document to update
      * @param {Array<UmbVariantId>} variantIds - The variants to publish after updating
-     * @returns {*}
+     * @returns {Promise<UmbRepositoryResponse<unknown>>} The result of the update and publish request
      * @memberof UmbDocumentPublishingRepository
      */
     async updateAndPublish(model, variantIds) {
@@ -31,11 +31,9 @@ export class UmbDocumentPublishingRepository extends UmbRepositoryBase {
     }
     /**
      * Publish one or more variants of a Document
-     * @param {string} id
-     * @param {Array<UmbVariantId>} variantIds
-     * @param unique
-     * @param variants
-     * @returns {*}
+     * @param {string} unique - The unique of the Document
+     * @param {Array<UmbDocumentVariantPublishModel>} variants - The variants to publish
+     * @returns {Promise<UmbRepositoryResponse<unknown>>} The result of the publish request
      * @memberof UmbDocumentPublishingRepository
      */
     async publish(unique, variants) {
@@ -47,9 +45,9 @@ export class UmbDocumentPublishingRepository extends UmbRepositoryBase {
     }
     /**
      * Unpublish one or more variants of a Document
-     * @param {string} id
-     * @param {Array<UmbVariantId>} variantIds
-     * @returns {*}
+     * @param {string} id - The unique of the Document
+     * @param {Array<UmbVariantId>} variantIds - The variants to unpublish
+     * @returns {Promise<UmbRepositoryResponse<unknown>>} The result of the unpublish request
      * @memberof UmbDocumentPublishingRepository
      */
     async unpublish(id, variantIds) {
@@ -61,9 +59,10 @@ export class UmbDocumentPublishingRepository extends UmbRepositoryBase {
     }
     /**
      * Publish variants of a document including its descendants
-     * @param id
-     * @param variantIds
-     * @param includeUnpublishedDescendants
+     * @param {string} id - The unique of the Document
+     * @param {Array<UmbVariantId>} variantIds - The variants to publish
+     * @param {boolean} includeUnpublishedDescendants - Whether to include unpublished descendants
+     * @returns {Promise<UmbRepositoryErrorResponse>} The result of the publish request
      * @memberof UmbDocumentPublishingRepository
      */
     async publishWithDescendants(id, variantIds, includeUnpublishedDescendants) {

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

@@ -5,7 +5,6 @@ import type { UmbDataSourceResponse } from '../../../../core/repository/index.js
 /**
  * A server data source for Document publishing
  * @class UmbDocumentPublishingServerDataSource
- * @implements {DocumentTreeDataSource}
  */
 export declare class UmbDocumentPublishingServerDataSource {
     #private;
@@ -20,7 +19,7 @@ export declare class UmbDocumentPublishingServerDataSource {
      * @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 {*}
+     * @returns {Promise<UmbDataSourceResponse>} The result of the create and publish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     createAndPublish(model: UmbDocumentDetailModel, variantIds: Array<UmbVariantId>, parentUnique?: string | null): Promise<import("../../../../core/resources/index.js").UmbApiResponse<{
@@ -32,7 +31,7 @@ export declare class UmbDocumentPublishingServerDataSource {
      * 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 {*}
+     * @returns {Promise<UmbDataSourceResponse>} The result of the update and publish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     updateAndPublish(model: UmbDocumentDetailModel, variantIds: Array<UmbVariantId>): Promise<import("../../../../core/resources/index.js").UmbApiResponse<{
@@ -42,10 +41,9 @@ export declare class UmbDocumentPublishingServerDataSource {
     }>>;
     /**
      * Publish one or more variants of a Document
-     * @param {string} unique
-     * @param {Array<UmbVariantId>} variantIds
-     * @param variants
-     * @returns {*}
+     * @param {string} unique - The unique of the Document
+     * @param {Array<UmbDocumentVariantPublishModel>} variants - The variants to publish
+     * @returns {Promise<UmbDataSourceResponse>} The result of the publish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     publish(unique: string, variants: Array<UmbDocumentVariantPublishModel>): Promise<import("../../../../core/resources/index.js").UmbApiResponse<{
@@ -55,9 +53,9 @@ export declare class UmbDocumentPublishingServerDataSource {
     }>>;
     /**
      * Unpublish one or more variants of a Document
-     * @param {string} unique
-     * @param {Array<UmbVariantId>} variantIds
-     * @returns {*}
+     * @param {string} unique - The unique of the Document
+     * @param {Array<UmbVariantId>} variantIds - The variants to unpublish
+     * @returns {Promise<UmbDataSourceResponse>} The result of the unpublish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     unpublish(unique: string, variantIds: Array<UmbVariantId>): Promise<import("../../../../core/resources/index.js").UmbApiResponse<{
@@ -67,15 +65,13 @@ export declare class UmbDocumentPublishingServerDataSource {
     }>>;
     /**
      * Publish variants of a document and all its descendants
-     * @param unique
-     * @param variantIds
-     * @param includeUnpublishedDescendants
+     * @param {string} unique - The unique of the Document
+     * @param {Array<UmbVariantId>} variantIds - The variants to publish
+     * @param {boolean} includeUnpublishedDescendants - Whether to include unpublished descendants
      * @memberof UmbDocumentPublishingServerDataSource
      */
     publishWithDescendants(unique: string, variantIds: Array<UmbVariantId>, includeUnpublishedDescendants: boolean): Promise<{
-        error: import("../../../../core/resources/index.js").UmbCancelError | import("../../../../core/resources/index.js").UmbApiError | undefined;
-    } | {
-        error: null;
+        error: import("../../../../core/resources/index.js").UmbError | import("../../../../core/resources/index.js").UmbCancelError | import("../../../../core/resources/index.js").UmbApiError | undefined;
     }>;
     /**
      * Get the published Document by its unique

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

@@ -5,7 +5,6 @@ import { tryExecute } from '../../../../core/resources/index.js';
 /**
  * A server data source for Document publishing
  * @class UmbDocumentPublishingServerDataSource
- * @implements {DocumentTreeDataSource}
  */
 export class UmbDocumentPublishingServerDataSource {
     #host;
@@ -22,7 +21,7 @@ export class UmbDocumentPublishingServerDataSource {
      * @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 {*}
+     * @returns {Promise<UmbDataSourceResponse>} The result of the create and publish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     async createAndPublish(model, variantIds, parentUnique = null) {
@@ -43,7 +42,7 @@ export class UmbDocumentPublishingServerDataSource {
      * 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 {*}
+     * @returns {Promise<UmbDataSourceResponse>} The result of the update and publish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     async updateAndPublish(model, variantIds) {
@@ -69,10 +68,9 @@ export class UmbDocumentPublishingServerDataSource {
     }
     /**
      * Publish one or more variants of a Document
-     * @param {string} unique
-     * @param {Array<UmbVariantId>} variantIds
-     * @param variants
-     * @returns {*}
+     * @param {string} unique - The unique of the Document
+     * @param {Array<UmbDocumentVariantPublishModel>} variants - The variants to publish
+     * @returns {Promise<UmbDataSourceResponse>} The result of the publish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     async publish(unique, variants) {
@@ -92,9 +90,9 @@ export class UmbDocumentPublishingServerDataSource {
     }
     /**
      * Unpublish one or more variants of a Document
-     * @param {string} unique
-     * @param {Array<UmbVariantId>} variantIds
-     * @returns {*}
+     * @param {string} unique - The unique of the Document
+     * @param {Array<UmbVariantId>} variantIds - The variants to unpublish
+     * @returns {Promise<UmbDataSourceResponse>} The result of the unpublish request
      * @memberof UmbDocumentPublishingServerDataSource
      */
     async unpublish(unique, variantIds) {
@@ -116,9 +114,9 @@ export class UmbDocumentPublishingServerDataSource {
     }
     /**
      * Publish variants of a document and all its descendants
-     * @param unique
-     * @param variantIds
-     * @param includeUnpublishedDescendants
+     * @param {string} unique - The unique of the Document
+     * @param {Array<UmbVariantId>} variantIds - The variants to publish
+     * @param {boolean} includeUnpublishedDescendants - Whether to include unpublished descendants
      * @memberof UmbDocumentPublishingServerDataSource
      */
     async publishWithDescendants(unique, variantIds, includeUnpublishedDescendants) {
@@ -144,7 +142,7 @@ export class UmbDocumentPublishingServerDataSource {
                 return { error };
             }
             if (data.isComplete) {
-                return { error: null };
+                return { error: undefined };
             }
         }
     }

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

@@ -50,7 +50,7 @@ let UmbDocumentScheduleModalElement = class UmbDocumentScheduleModalElement exte
             const missingMandatoryOptions = this._options.filter(isNotPublishedMandatory);
             this._hasNotSelectedMandatory = missingMandatoryOptions.some((option) => !selection.includes(option.unique));
             this.requestUpdate();
-        }, '_selection');
+        }, null);
     }
     firstUpdated() {
         this._internalValues = this.data?.prevalues ? [...this.data.prevalues] : [];
@@ -118,7 +118,7 @@ let UmbDocumentScheduleModalElement = class UmbDocumentScheduleModalElement exte
         return this._selection.length !== 0 && this._selection.length === allowedUniques.length;
     }
     render() {
-        return html `<uui-dialog-layout headline=${this.localize.term('general_scheduledPublishing')}>
+        return html `<uui-dialog-layout headline=${this.localize.term('content_saveAndScheduleModalTitle')}>
 			${this.#renderOptions()}
 
 			<div slot="actions">

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

@@ -3,18 +3,12 @@ import { UmbDocumentUnpublishManifestEntityActionMeta } from '../entity-action/c
 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 { UMB_CONTENT_UNPUBLISH_MODAL, UmbBulkContentPublishingController, 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';
 import { UmbVariantId } from '../../../../../core/variant/index.js';
-import { UmbLocalizationController } from '../../../../../../libs/localization-api/index.js';
 import { UMB_ENTITY_CONTEXT } from '../../../../../core/entity/index.js';
-import { UMB_ACTION_EVENT_CONTEXT } from '../../../../../core/action/index.js';
-import { UmbRequestReloadChildrenOfEntityEvent } from '../../../../../core/entity-action/index.js';
-import { UMB_NOTIFICATION_CONTEXT } from '../../../../../core/notification/index.js';
 export class UmbDocumentUnpublishEntityBulkAction extends UmbEntityBulkActionBase {
     async execute() {
         const entityContext = await this.getContext(UMB_ENTITY_CONTEXT);
@@ -41,16 +35,10 @@ export class UmbDocumentUnpublishEntityBulkAction extends UmbEntityBulkActionBas
         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.requestAllItems(),
-        ]);
-        if (!documentItems?.length)
+        const variantOptions = await UmbDocumentPublishEntityBulkAction.requestBulkVariantOptions(this._host, this.selection);
+        if (!variantOptions)
             return;
-        const { allInvariant, options } = UmbDocumentPublishEntityBulkAction.buildVariantOptions(documentItems, languageData?.items ?? []);
+        const { allInvariant, options } = variantOptions;
         // 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) {
             return this.#unpublishSingleVariant(entityType, unique, options, allInvariant);
@@ -70,16 +58,7 @@ export class UmbDocumentUnpublishEntityBulkAction extends UmbEntityBulkActionBas
         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);
+        await this.#bulkUnpublish([variantId], entityType, unique);
     }
     async #unpublishSelectedVariants(entityType, unique, options) {
         // Pre-select all cultures from the selected documents
@@ -94,16 +73,7 @@ export class UmbDocumentUnpublishEntityBulkAction extends UmbEntityBulkActionBas
         const variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
         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);
+        await this.#bulkUnpublish(variantIds, entityType, unique);
     }
     static #renderDocumentCountLabel(option) {
         const documentCount = option.documentCount;
@@ -113,22 +83,23 @@ export class UmbDocumentUnpublishEntityBulkAction extends UmbEntityBulkActionBas
 				</div>`
             : nothing;
     }
-    async #unpublishDocuments(uniques, variantIds) {
+    // Unpublishes the selection sequentially in a progress dialog, then reports the outcome and reloads.
+    async #bulkUnpublish(variantIds, entityType, unique) {
         const repository = new UmbDocumentPublishingRepository(this._host);
-        let successCount = 0;
-        for (const unique of uniques) {
-            const { error } = await repository.unpublish(unique, variantIds);
-            if (!error)
-                successCount++;
-        }
-        return successCount;
-    }
-    async #reloadChildren(entityType, unique) {
-        const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
-        if (!eventContext)
-            return;
-        const event = new UmbRequestReloadChildrenOfEntityEvent({ entityType, unique });
-        eventContext.dispatchEvent(event);
+        await new UmbBulkContentPublishingController(this).run({
+            selection: this.selection,
+            entityType,
+            unique,
+            headline: '#unpublish_inProgress',
+            variantIds,
+            labels: {
+                headline: 'speechBubbles_contentUnpublished',
+                multiVariant: 'speechBubbles_editMultiVariantUnpublishedText',
+                multiContent: 'speechBubbles_editMultiContentUnpublishedText',
+                partial: 'speechBubbles_editMultiContentUnpublishedPartialText',
+            },
+            process: (documentUnique) => repository.unpublish(documentUnique, variantIds),
+        });
     }
 }
 _a = UmbDocumentUnpublishEntityBulkAction;

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

@@ -27,13 +27,13 @@ export declare class UmbDocumentPublishingWorkspaceContext extends UmbContextBas
      */
     schedule(): Promise<void>;
     /**
-     * Publish the document with descendants
+     * Save the document and publish it with descendants
      * @returns {Promise<void>}
      * @memberof UmbDocumentPublishingWorkspaceContext
      */
     publishWithDescendants(): Promise<void>;
     /**
-     * Unpublish the document
+     * Unpublish the document, asking to discard any unsaved changes first
      * @returns {Promise<void>}
      * @memberof UmbDocumentPublishingWorkspaceContext
      */

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

@@ -5,12 +5,12 @@ import { UMB_DOCUMENT_SCHEDULE_MODAL } from '../schedule-publish/constants.js';
 import { UMB_DOCUMENT_PUBLISH_WITH_DESCENDANTS_MODAL } from '../publish-with-descendants/constants.js';
 import { UmbDocumentUnpublishManifestEntityActionMeta } from '../unpublish/entity-action/constants.js';
 import { UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_WORKSPACE_ALIAS } from '../../constants.js';
+import { UmbDocumentVariantState } from '../../variant-state.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_DISCARD_CHANGES_MODAL, 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';
@@ -27,6 +27,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
     #publishedDocumentData;
     #loadingPublishedData;
     #currentUnique;
+    #variesByCulture;
     #notificationContext;
     #localize;
     constructor(host) {
@@ -195,7 +196,8 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
      * Convert a date string to a server time string in ISO format, example: 2021-01-01T12:00:00.000+00:00.
      * The input must be a valid date string, otherwise it will return null.
      * The output matches the DateTimeOffset format in C#.
-     * @param dateString
+     * @param {string | null | undefined} dateString - The date string to convert.
+     * @returns {string | null} The ISO date string, or null if invalid.
      */
     #convertToDateTimeOffset(dateString) {
         if (!dateString || dateString.length === 0) {
@@ -210,7 +212,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         return date.toISOString();
     }
     /**
-     * Publish the document with descendants
+     * Save the document and publish it with descendants
      * @returns {Promise<void>}
      * @memberof UmbDocumentPublishingWorkspaceContext
      */
@@ -238,37 +240,113 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
         if (!variantIds.length)
             return;
-        const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
-        const localize = new UmbLocalizationController(this);
-        const primaryVariantName = this.#documentWorkspaceContext.getName(variantIds[0]) ?? '';
-        const waitNotice = notificationContext?.peek('warning', {
+        const workspaceContext = this.#documentWorkspaceContext;
+        const saveData = await workspaceContext.constructSaveData(variantIds);
+        try {
+            await workspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
+        }
+        catch (error) {
+            // This throws before the submit flow starts, so nothing downstream tells the user why. [JOV]
+            this.#notify('danger', 'speechBubbles_editContentPublishedFailedByValidation');
+            throw error;
+        }
+        await workspaceContext.askServerToValidate(saveData, variantIds);
+        return workspaceContext.validateVariantsAndSubmit(variantIds, () => this.#performPublishWithDescendants({
+            workspaceContext,
+            unique,
+            entityType,
+            variantIds,
+            saveData,
+            includeUnpublishedDescendants: result.includeUnpublishedDescendants ?? false,
+        }), (reason) => this.#saveWithoutPublishing(variantIds, saveData, reason));
+    }
+    async #performPublishWithDescendants(args) {
+        const { workspaceContext, unique, entityType, variantIds } = args;
+        const primaryVariantName = workspaceContext.getName(variantIds[0]) ?? '';
+        const waitNotice = this.#notificationContext?.peek('warning', {
             data: {
-                headline: localize.term('publish_publishAll', primaryVariantName),
-                message: localize.term('publish_inProgress'),
+                headline: this.#localize.term('publish_publishAll', primaryVariantName),
+                message: this.#localize.term('publish_inProgress'),
             },
         });
-        const { error } = await this.#publishingRepository.publishWithDescendants(unique, variantIds, result.includeUnpublishedDescendants ?? false);
-        waitNotice?.close();
-        if (!error) {
-            notificationContext?.peek('positive', {
-                data: {
-                    message: localize.term('publish_nodePublishAll', primaryVariantName),
-                },
+        let readBackFailed;
+        try {
+            // Each failure path notifies at the point it happens, so that a publish failure after a
+            // successful save does not claim the document was not saved. (#14925 review)
+            readBackFailed = await this.#saveAndPublishDescendants(args);
+        }
+        finally {
+            waitNotice?.close();
+        }
+        this.#notify('positive', 'publish_nodePublishAll', primaryVariantName);
+        if (readBackFailed) {
+            this.#notify('warning', 'speechBubbles_editContentPublishedReloadFailed');
+        }
+        await this.#loadAndProcessLastPublished();
+        // The save above already dispatched the structure-reload event; the descendants need the children one.
+        this.#eventContext?.dispatchEvent(new UmbRequestReloadChildrenOfEntityEvent({ entityType, unique }));
+    }
+    /**
+     * Peeks a single-message notification, when a notification context is available.
+     * @param {UmbNotificationColor} color - The notification color/severity.
+     * @param {string} messageKey - The localization key for the message.
+     * @param {...string} args - Arguments to interpolate into the localized message.
+     */
+    #notify(color, messageKey, ...args) {
+        this.#notificationContext?.peek(color, { data: { message: this.#localize.term(messageKey, ...args) } });
+    }
+    /**
+     * Saves the selected variants, then publishes them with their descendants. The two are separate
+     * server calls, so the save goes through the default persistence path first: it merges the response
+     * into those variants only and dispatches the save events, leaving the workspace correctly saved
+     * even when the publish leg fails afterwards.
+     * @param {UmbDocumentPublishWithDescendantsArgs} args - The publish arguments.
+     * @returns {Promise<boolean>} whether reading the document back after publishing failed
+     */
+    async #saveAndPublishDescendants(args) {
+        const { workspaceContext, unique, variantIds, saveData, includeUnpublishedDescendants } = args;
+        try {
+            await workspaceContext.performCreateOrUpdate(variantIds, saveData);
+        }
+        catch (error) {
+            this.#notify('danger', 'speechBubbles_editContentPublishedFailed');
+            throw error;
+        }
+        const { error } = await this.#publishingRepository.publishWithDescendants(unique, variantIds, includeUnpublishedDescendants);
+        if (error) {
+            // The document is saved at this point, so do not tell the user that it is not.
+            this.#notify('danger', 'speechBubbles_editContentPublishedFailedByValidation');
+            throw new Error('Error publishing document with descendants', { cause: error });
+        }
+        // Publishing changed the variant states, so read them back the same variant-scoped way rather
+        // than through reload(), which would replace edits in variants that were not published.
+        try {
+            await workspaceContext.performCreateOrUpdate(variantIds, saveData, {
+                update: () => workspaceContext.loadWithoutPersist(),
             });
-            // 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
-            const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
-            this.#eventContext?.dispatchEvent(structureEvent);
-            // request reload of the children
-            const childrenEvent = new UmbRequestReloadChildrenOfEntityEvent({ entityType, unique });
-            this.#eventContext?.dispatchEvent(childrenEvent);
+            return false;
         }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Save the selected variants without publishing them, for when validation rejects the publish.
+     * Rejects even though the save succeeded, to symbolize that we did not publish. [NL]
+     * @param {Array<UmbVariantId>} variantIds - The variants to save.
+     * @param {UmbDocumentDetailModel} saveData - The data to save.
+     * @param {unknown} reason - The reason the publish was rejected, rethrown after saving.
+     */
+    async #saveWithoutPublishing(variantIds, saveData, reason) {
+        if (!this.#documentWorkspaceContext)
+            throw new Error('Document workspace context is missing');
+        await this.#documentWorkspaceContext.performCreateOrUpdate(variantIds, saveData);
+        // TODO: Get rid of the save notification.
+        this.#notify('danger', 'speechBubbles_editContentPublishedFailedByValidation');
+        throw reason;
     }
     /**
-     * Unpublish the document
+     * Unpublish the document, asking to discard any unsaved changes first
      * @returns {Promise<void>}
      * @memberof UmbDocumentPublishingWorkspaceContext
      */
@@ -282,6 +360,9 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const entityType = this.#documentWorkspaceContext.getEntityType();
         if (!entityType)
             throw new Error('Entity type is missing');
+        // Unpublishing reloads the workspace, which discards any unsaved edit, so let the user confirm that.
+        if (!(await this.#confirmDiscardingUnsavedChanges()))
+            return;
         const action = new UmbContentUnpublishEntityAction(this, {
             unique,
             entityType,
@@ -295,6 +376,15 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         await this.#documentWorkspaceContext.reload();
         await this.#loadAndProcessLastPublished();
     }
+    /**
+     * Asks whether to discard unsaved changes, for actions that replace the workspace data.
+     * @returns {Promise<boolean>} false when the user chose to keep their changes
+     */
+    async #confirmDiscardingUnsavedChanges() {
+        if (!this.#documentWorkspaceContext?.getHasUnpersistedChanges())
+            return true;
+        return umbOpenModal(this, UMB_DISCARD_CHANGES_MODAL).then(() => true, () => false);
+    }
     async #handleSaveAndPublish(executionOptions) {
         await this.#init;
         if (!this.#documentWorkspaceContext)
@@ -342,21 +432,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                 });
                 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', {
-                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]
-            return await Promise.reject(reason);
-        });
+        }, (reason) => this.#saveWithoutPublishing(variantIds, saveData, reason));
     }
     async #performSaveAndPublish(variantIds, saveData) {
         await this.#init;
@@ -473,6 +549,19 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                 this.#processPendingChanges();
             }
         }, 'umbPersistedDataObserver');
+        this.observe(this.#documentWorkspaceContext.variesByCulture, (variesByCulture) => {
+            const previousVariesByCulture = this.#variesByCulture;
+            this.#variesByCulture = variesByCulture;
+            if (previousVariesByCulture === undefined ||
+                variesByCulture === undefined ||
+                previousVariesByCulture === variesByCulture) {
+                return;
+            }
+            // The server migrates the published version when the content type's variance changes,
+            // so the cached copy no longer compares correctly against the persisted data:
+            this.#publishedDocumentData = undefined;
+            this.#loadAndProcessLastPublished().catch(() => undefined);
+        }, 'umbVariesByCultureObserver');
     }
     #hasPublishedVariant() {
         // Use persisted data (falls back to current) because this may be called

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/bulk-trash/document-bulk-trash-with-relation.action.js

@@ -1,5 +1,5 @@
 import { UMB_DOCUMENT_CONFIGURATION_CONTEXT } from '../../../global-contexts/index.js';
-import { UMB_BULK_TRASH_WITH_RELATION_CONFIRM_MODAL, UmbBulkTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+import { UMB_BULK_TRASH_WITH_RELATION_CONFIRM_MODAL, UmbBulkTrashWithRelationEntityAction, } from '../../../../../relations/relations/index.js';
 import { umbOpenModal } from '../../../../../core/modal/index.js';
 export class UmbDocumentBulkTrashWithRelationEntityAction extends UmbBulkTrashWithRelationEntityAction {
     async _confirmTrash() {

package/dist-cms/packages/documents/documents/recycle-bin/entity-action/trash/document-trash-with-relation.action.js

@@ -1,7 +1,6 @@
 import { UMB_DOCUMENT_CONFIGURATION_CONTEXT } from '../../../global-contexts/index.js';
-import { UMB_TRASH_WITH_RELATION_CONFIRM_MODAL } from '../../../../../relations/relations/index.js';
+import { UMB_TRASH_WITH_RELATION_CONFIRM_MODAL, UmbTrashWithRelationEntityAction, } from '../../../../../relations/relations/index.js';
 import { umbOpenModal } from '../../../../../core/modal/index.js';
-import { UmbTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
 export class UmbDocumentTrashWithRelationEntityAction extends UmbTrashWithRelationEntityAction {
     async _confirmTrash(item) {
         const configContext = await this.getContext(UMB_DOCUMENT_CONFIGURATION_CONTEXT);

package/dist-cms/packages/documents/documents/recycle-bin/repository/document-recycle-bin.server.data-source.d.ts

@@ -24,7 +24,7 @@ export declare class UmbDocumentRecycleBinServerDataSource implements UmbRecycle
         } | null;
         error?: undefined;
     } | {
-        error: import("../../../../core/resources/index.js").UmbCancelError | import("../../../../core/resources/index.js").UmbApiError | undefined;
+        error: import("../../../../core/resources/index.js").UmbError | import("../../../../core/resources/index.js").UmbCancelError | import("../../../../core/resources/index.js").UmbApiError | undefined;
         data?: undefined;
     }>;
 }