@umbraco-cms/backoffice 18.3.0-rc → 19.0.0-beta1

package/dist-cms/packages/elements/publishing/manifests.js

@@ -1,9 +1,11 @@
+import { manifests as awarenessManifests } from './awareness/manifests.js';
 import { manifests as repositoryManifests } from './repository/manifests.js';
 import { manifests as workspaceContextManifests } from './workspace-context/manifests.js';
 import { manifests as publishManifests } from './publish/manifests.js';
 import { manifests as unpublishManifests } from './unpublish/manifests.js';
 import { manifests as schedulePublishManifests } from './schedule-publish/manifests.js';
 export const manifests = [
+    ...awarenessManifests,
     ...repositoryManifests,
     ...workspaceContextManifests,
     ...publishManifests,

package/dist-cms/packages/elements/publishing/publish/entity-action/constants.js

@@ -1,4 +1,5 @@
 import { UMB_ELEMENT_DETAIL_REPOSITORY_ALIAS } from '../../../repository/detail/constants.js';
+import { UMB_ELEMENT_ITEM_REPOSITORY_ALIAS, UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS } from '../../../constants.js';
 import { UMB_ELEMENT_PUBLISHING_REPOSITORY_ALIAS } from '../../repository/constants.js';
 export const UmbElementPublishManifestEntityActionMeta = {
     icon: 'icon-globe',
@@ -6,6 +7,8 @@ export const UmbElementPublishManifestEntityActionMeta = {
     additionalOptions: true,
     detailRepositoryAlias: UMB_ELEMENT_DETAIL_REPOSITORY_ALIAS,
     publishingRepositoryAlias: UMB_ELEMENT_PUBLISHING_REPOSITORY_ALIAS,
+    itemRepositoryAlias: UMB_ELEMENT_ITEM_REPOSITORY_ALIAS,
+    referenceRepositoryAlias: UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS,
     publishedNotificationMessage: '#speechBubbles_editElementPublishedHeader',
     variantPublishedNotificationMessage: '#speechBubbles_editVariantElementPublishedText',
 };

package/dist-cms/packages/elements/publishing/publish/modal/element-publish-modal.element.d.ts

@@ -9,6 +9,7 @@ export declare class UmbElementPublishModalElement extends UmbModalBaseElement<U
     private _hasNotSelectedMandatory?;
     private _hasInvalidSelection;
     private _isInvariant;
+    private _referenceCount?;
     firstUpdated(): void;
     render(): import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];

package/dist-cms/packages/elements/publishing/publish/modal/element-publish-modal.element.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { UmbElementVariantState } from '../../../variant-state.js';
+import { UmbElementReferenceRepository } from '../../../reference/repository/element-reference.repository.js';
 import { css, customElement, html, state, when } from '../../../../../external/lit/index.js';
 import { umbFocus } from '../../../../core/lit-element/index.js';
 import { UmbModalBaseElement } from '../../../../core/modal/index.js';
@@ -47,9 +48,19 @@ let UmbElementPublishModalElement = class UmbElementPublishModalElement extends
         if (this.data?.options.length === 1 && this.data.options[0].culture === null) {
             this._isInvariant = true;
             this._hasInvalidSelection = false;
-            return;
         }
-        this.#configureSelectionManager();
+        else {
+            this.#configureSelectionManager();
+        }
+        this.#fetchReferenceCount();
+    }
+    async #fetchReferenceCount() {
+        const unique = this.data?.unique;
+        if (!unique)
+            return;
+        const referenceRepository = new UmbElementReferenceRepository(this);
+        const { data } = await referenceRepository.requestReferencedBy(unique);
+        this._referenceCount = data?.total ?? 0;
     }
     async #configureSelectionManager() {
         this.#selectionManager.setMultiple(true);
@@ -90,6 +101,13 @@ let UmbElementPublishModalElement = class UmbElementPublishModalElement extends
 							.variantLanguageOptions=${this._options}
 							.requiredFilter=${isNotPublishedMandatory}
 							.pickableFilter=${this.#pickableFilter}></umb-element-variant-language-picker>`)}
+				${when(this._referenceCount !== undefined && this._referenceCount > 0, () => html `
+						<p class="reference-info">
+							<umb-localize key="blockEditor_elementUsedByCount" .args=${[this._referenceCount]}>
+								This element is used by ${this._referenceCount} item(s).
+							</umb-localize>
+						</p>
+					`)}
 
 				<div slot="actions">
 					<uui-button label=${this.localize.term('general_close')} @click=${this.#close}></uui-button>
@@ -114,6 +132,11 @@ let UmbElementPublishModalElement = class UmbElementPublishModalElement extends
 				min-width: 460px;
 				max-width: 90vw;
 			}
+
+			.reference-info {
+				color: var(--uui-color-text-alt);
+				font-size: var(--uui-type-small-size);
+			}
 		`,
     ]; }
 };
@@ -129,6 +152,9 @@ __decorate([
 __decorate([
     state()
 ], UmbElementPublishModalElement.prototype, "_isInvariant", void 0);
+__decorate([
+    state()
+], UmbElementPublishModalElement.prototype, "_referenceCount", void 0);
 UmbElementPublishModalElement = __decorate([
     customElement('umb-element-publish-modal')
 ], UmbElementPublishModalElement);

package/dist-cms/packages/elements/publishing/publish/modal/element-publish-modal.token.d.ts

@@ -11,6 +11,7 @@ export declare const UMB_ELEMENT_PUBLISH_MODAL_ALIAS = "Umb.Modal.ElementPublish
 export interface UmbElementPublishModalData extends UmbElementVariantPickerData {
     headline?: string;
     confirmLabel?: string;
+    unique?: string;
 }
 /** @deprecated Use `UmbContentPublishModalValue` from `@umbraco-cms/backoffice/content` instead. Scheduled for removal in Umbraco 20. */
 export interface UmbElementPublishModalValue extends UmbElementVariantPickerValue {

package/dist-cms/packages/elements/publishing/repository/element-publishing.server.data-source.d.ts

@@ -1,7 +1,7 @@
 import type { UmbElementVariantPublishModel } from '../types.js';
 import type { UmbElementDetailModel } from '../../types.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
-import type { UmbVariantId } from '../../../core/variant/index.js';
+import { type UmbVariantId } from '../../../core/variant/index.js';
 import type { UmbDataSourceResponse } from '../../../core/repository/index.js';
 /**
  * A server data source for Element publishing

package/dist-cms/packages/elements/publishing/repository/element-publishing.server.data-source.js

@@ -2,6 +2,7 @@ import { umbMapElementResponseToDetailModel } from '../../repository/detail/elem
 import { umbMapElementCreateRequestBody, umbMapElementUpdateRequestBody, } from '../../repository/detail/element-detail-request.mappers.js';
 import { tryExecute } from '../../../core/resources/index.js';
 import { ElementService } from '../../../core/backend-api/index.js';
+import { umbVariantIdsToCultures } from '../../../core/variant/index.js';
 /**
  * A server data source for Element publishing
  * @class UmbElementPublishingServerDataSource
@@ -67,7 +68,7 @@ export class UmbElementPublishingServerDataSource {
      * @returns {Array<string>} The distinct culture codes to publish
      */
     #mapCulturesToPublish(variantIds) {
-        return [...new Set(variantIds.filter((x) => !x.isCultureInvariant()).map((x) => x.toCultureString()))];
+        return umbVariantIdsToCultures(variantIds).filter((x) => x !== null);
     }
     /**
      * Publish one or more variants of an Element

package/dist-cms/packages/elements/publishing/schedule-publish/modal/element-schedule-modal.element.d.ts

@@ -1,5 +1,6 @@
 import type { UmbElementScheduleModalData, UmbElementScheduleModalValue } from './element-schedule-modal.token.js';
 import { UmbModalBaseElement } from '../../../../core/modal/index.js';
+import '../../../../relations/relations/index.js';
 export declare class UmbElementScheduleModalElement extends UmbModalBaseElement<UmbElementScheduleModalData, UmbElementScheduleModalValue> {
     #private;
     private _options;
@@ -8,6 +9,7 @@ export declare class UmbElementScheduleModalElement extends UmbModalBaseElement<
     private _isAllSelected;
     private _internalValues;
     private _submitButtonState?;
+    private _referencesConfig?;
     constructor();
     firstUpdated(): void;
     render(): import("lit-html").TemplateResult<1>;

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

@@ -8,10 +8,10 @@ import { UmbElementVariantState } from '../../../variant-state.js';
 import { isNotPublishedMandatory } from '../../utils.js';
 import { UmbElementVariantLanguagePickerElement } from '../../../modals/index.js';
 import { css, customElement, html, ref, repeat, state, when } from '../../../../../external/lit/index.js';
+import { umbBindToValidation, UmbValidationContext } from '../../../../core/validation/index.js';
 import { UmbModalBaseElement } from '../../../../core/modal/index.js';
-import { UmbTextStyles } from '../../../../core/style/index.js';
 import { UmbSelectionManager } from '../../../../core/utils/index.js';
-import { umbBindToValidation, UmbValidationContext } from '../../../../core/validation/index.js';
+import '../../../../relations/relations/index.js';
 let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extends UmbModalBaseElement {
     #selectionManager;
     #validation;
@@ -55,6 +55,19 @@ let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extend
     firstUpdated() {
         this._internalValues = this.data?.prevalues ? [...this.data.prevalues] : [];
         this.#configureSelectionManager();
+        this.#configureReferences();
+    }
+    #configureReferences() {
+        if (!this.data)
+            return;
+        const { unique, itemRepositoryAlias, referenceRepositoryAlias } = this.data;
+        if (!unique)
+            return;
+        if (!itemRepositoryAlias)
+            return;
+        if (!referenceRepositoryAlias)
+            return;
+        this._referencesConfig = { unique, itemRepositoryAlias, referenceRepositoryAlias };
     }
     async #configureSelectionManager() {
         this.#selectionManager.setMultiple(true);
@@ -100,6 +113,10 @@ let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extend
     #isSelected(unique) {
         return this._selection.some((s) => s.unique === unique);
     }
+    #hasSelectableOption() {
+        const isAllowed = this.#selectionManager.getAllowLimitation();
+        return this._options.some((option) => isAllowed(option.unique));
+    }
     #onSelectAllChange(event) {
         const allUniques = this._options.map((o) => o.unique);
         const filter = this.#selectionManager.getAllowLimitation();
@@ -118,20 +135,24 @@ let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extend
         return this._selection.length !== 0 && this._selection.length === allowedUniques.length;
     }
     render() {
-        return html `<uui-dialog-layout headline=${this.localize.term('general_scheduledPublishing')}>
-			${this.#renderOptions()}
-
-			<div slot="actions">
-				<uui-button label=${this.localize.term('general_close')} @click=${this.#close}></uui-button>
-				<uui-button
-					.state=${this._submitButtonState}
-					label="${this.localize.term('buttons_schedulePublish')}"
-					look="primary"
-					color="positive"
-					?disabled=${!this._selection.length || this._hasNotSelectedMandatory}
-					@click=${this.#submit}></uui-button>
-			</div>
-		</uui-dialog-layout> `;
+        return html `
+			<uui-dialog-layout headline=${this.localize.term('general_scheduledPublishing')}>
+				${this.#renderOptions()}
+				${when(this._referencesConfig, () => html `<umb-entity-references-summary
+							.config=${this._referencesConfig}
+							.entitiesNeedingAttention=${this.data?.entitiesNeedingAttention}></umb-entity-references-summary>`)}
+				<div slot="actions">
+					<uui-button label=${this.localize.term('general_close')} @click=${this.#close}></uui-button>
+					<uui-button
+						.state=${this._submitButtonState}
+						label="${this.localize.term('buttons_schedulePublish')}"
+						look="primary"
+						color="positive"
+						?disabled=${!this._selection.length || this._hasNotSelectedMandatory}
+						@click=${this.#submit}></uui-button>
+				</div>
+			</uui-dialog-layout>
+		`;
     }
     #renderOptions() {
         return html `
@@ -139,7 +160,8 @@ let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extend
 					<uui-checkbox
 						@change=${this.#onSelectAllChange}
 						label=${this.localize.term('general_selectAll')}
-						.checked=${this._isAllSelected}></uui-checkbox>
+						.checked=${this._isAllSelected}
+						?disabled=${!this.#hasSelectableOption()}></uui-checkbox>
 				`)}
 			${repeat(this._options, (option) => option.unique, (option) => this.#renderItem(option))}
 		`;
@@ -161,9 +183,9 @@ let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extend
 				${UmbElementVariantLanguagePickerElement.renderLabel(option)}
 			</uui-menu-item>
 			${when(this.#isSelected(option.unique), () => this.#renderPublishDateInput(option, fromDate, toDate))}
-			${when(isChanged, () => html `<p>
-						${this.localize.term('content_scheduledPendingChanges', this.localize.term('buttons_schedulePublish'))}
-					</p>`)}
+			${when(isChanged, () => html `
+					<p>${this.localize.term('content_scheduledPendingChanges', this.localize.term('buttons_schedulePublish'))}</p>
+				`)}
 		`;
     }
     #attachValidatorsToPublish(element) {
@@ -340,7 +362,6 @@ let UmbElementScheduleModalElement = class UmbElementScheduleModalElement extend
         return value.length ? value : null;
     }
     static { this.styles = [
-        UmbTextStyles,
         css `
 			:host {
 				display: block;
@@ -403,6 +424,9 @@ __decorate([
 __decorate([
     state()
 ], UmbElementScheduleModalElement.prototype, "_submitButtonState", void 0);
+__decorate([
+    state()
+], UmbElementScheduleModalElement.prototype, "_referencesConfig", void 0);
 UmbElementScheduleModalElement = __decorate([
     customElement('umb-element-schedule-modal')
 ], UmbElementScheduleModalElement);

package/dist-cms/packages/elements/publishing/schedule-publish/modal/element-schedule-modal.token.d.ts

@@ -1,6 +1,7 @@
 import type { UmbElementVariantPickerData } from '../../../modals/types.js';
 import { UmbModalToken } from '../../../../core/modal/index.js';
 import type { ScheduleRequestModel } from '../../../../core/backend-api/index.js';
+import type { UmbEntityModel } from '../../../../core/entity/index.js';
 export declare const UMB_ELEMENT_SCHEDULE_MODAL_ALIAS = "Umb.Modal.ElementSchedule";
 export interface UmbElementScheduleSelectionModel {
     unique: string;
@@ -9,6 +10,11 @@ export interface UmbElementScheduleSelectionModel {
 export interface UmbElementScheduleModalData extends UmbElementVariantPickerData {
     activeVariants: Array<string>;
     prevalues: Array<UmbElementScheduleSelectionModel>;
+    unique?: string;
+    itemRepositoryAlias?: string;
+    referenceRepositoryAlias?: string;
+    /** Entities directly referenced by this entity's current draft that need attention before publishing. */
+    entitiesNeedingAttention?: Array<UmbEntityModel>;
 }
 export interface UmbElementScheduleModalValue {
     selection: Array<UmbElementScheduleSelectionModel>;

package/dist-cms/packages/elements/publishing/workspace-context/element-publishing.workspace-context.d.ts

@@ -1,4 +1,5 @@
 import { UmbElementPublishedPendingChangesManager } from '../pending-changes/index.js';
+import { UmbEntityReferenceCountManager } from '../../../relations/relations/index.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 import type { UmbPublishableWorkspaceContext, UmbWorkspaceActionExecutionOptions } from '../../../core/workspace/index.js';
@@ -9,6 +10,14 @@ export declare class UmbElementPublishingWorkspaceContext extends UmbContextBase
      * @memberof UmbElementPublishingWorkspaceContext
      */
     readonly publishedPendingChanges: UmbElementPublishedPendingChangesManager;
+    /**
+     * Tracks how many items reference this element, so the publish flow can decide whether the confirmation
+     * dialog has anything to say for a single-variant element (it always has something to say once there are
+     * multiple variants to choose between). Loaded lazily, at the point of publishing/scheduling, rather than
+     * on workspace load.
+     * @memberof UmbElementPublishingWorkspaceContext
+     */
+    readonly referenceCount: UmbEntityReferenceCountManager;
     workspaceAlias: string;
     constructor(host: UmbControllerHost);
     getEntityType(): string;

package/dist-cms/packages/elements/publishing/workspace-context/element-publishing.workspace-context.js

@@ -1,5 +1,6 @@
 import { UMB_ELEMENT_WORKSPACE_CONTEXT } from '../../workspace/element-workspace.context-token.js';
 import { UmbElementVariantState } from '../../variant-state.js';
+import { UMB_ELEMENT_ITEM_REPOSITORY_ALIAS, UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS } from '../../constants.js';
 import { UmbElementPublishingRepository } from '../repository/index.js';
 import { UmbElementPublishedPendingChangesManager } from '../pending-changes/index.js';
 import { UmbElementUnpublishManifestEntityActionMeta } from '../unpublish/entity-action/constants.js';
@@ -8,19 +9,26 @@ import { UMB_ELEMENT_ENTITY_TYPE } from '../../entity.js';
 import { UMB_ELEMENT_WORKSPACE_ALIAS } from '../../workspace/constants.js';
 import { UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT } from './element-publishing.workspace-context.token.js';
 import { UMB_ELEMENT_PUBLISHING_SHORTCUT_UNIQUE } from './constants.js';
-import { firstValueFrom } from '../../../../external/rxjs/index.js';
+import { umbNeedsPublishConfirmation } from './needs-publish-confirmation.function.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 { UMB_CONTENT_PUBLISH_MODAL, UmbContentReferencedEntitiesManager, UmbContentUnpublishEntityAction, } from '../../../content/content/index.js';
+import { UmbEntityReferenceCountManager } from '../../../relations/relations/index.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbLocalizationController } from '../../../../libs/localization-api/index.js';
 import { UmbRequestReloadStructureForEntityEvent } from '../../../core/entity-action/index.js';
-import { UmbVariantId } from '../../../core/variant/index.js';
+import { UmbVariantId, umbExpandVariantIdsWithSegmentOptions } from '../../../core/variant/index.js';
 import { UMB_ACTION_EVENT_CONTEXT } from '../../../core/action/index.js';
 import { apiErrorWasNotified } from '../../../core/resources/index.js';
 import { UMB_NOTIFICATION_CONTEXT } from '../../../core/notification/index.js';
 import { notifyWorkspaceActionStarting } from '../../../core/workspace/index.js';
 export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
+    /**
+     * Resolves the elements this element directly references (via its draft property values) that are not
+     * fully published, for the same publish-confirmation decision as {@link referenceCount}.
+     * @memberof UmbElementPublishingWorkspaceContext
+     */
+    #referencedEntities;
     #init;
     #elementWorkspaceContext;
     #eventContext;
@@ -36,15 +44,28 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
          * @memberof UmbElementPublishingWorkspaceContext
          */
         this.publishedPendingChanges = new UmbElementPublishedPendingChangesManager(this);
+        /**
+         * Tracks how many items reference this element, so the publish flow can decide whether the confirmation
+         * dialog has anything to say for a single-variant element (it always has something to say once there are
+         * multiple variants to choose between). Loaded lazily, at the point of publishing/scheduling, rather than
+         * on workspace load.
+         * @memberof UmbElementPublishingWorkspaceContext
+         */
+        this.referenceCount = new UmbEntityReferenceCountManager(this, {
+            referenceRepositoryAlias: UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS,
+            prefetch: false,
+        });
+        /**
+         * Resolves the elements this element directly references (via its draft property values) that are not
+         * fully published, for the same publish-confirmation decision as {@link referenceCount}.
+         * @memberof UmbElementPublishingWorkspaceContext
+         */
+        this.#referencedEntities = new UmbContentReferencedEntitiesManager(this);
         this.#publishingRepository = new UmbElementPublishingRepository(this);
         this.#localize = new UmbLocalizationController(this);
         this.workspaceAlias = UMB_ELEMENT_WORKSPACE_ALIAS;
         this.#publishableVariantsFilter = (option) => {
-            const variantId = UmbVariantId.Create(option);
-            // If the read only guard is permitted it means the variant is read only
-            const isReadOnly = this.#elementWorkspaceContext.readOnlyGuard.getIsPermittedForVariant(variantId);
-            // If the variant is read only, we can't publish it
-            return !isReadOnly;
+            return this.#elementWorkspaceContext.getIsWritableVariant(UmbVariantId.Create(option));
         };
         this.#init = Promise.all([
             this.consumeContext(UMB_ELEMENT_WORKSPACE_CONTEXT, async (context) => {
@@ -124,6 +145,7 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
         // Reload workspace data to reflect the unpublished state
         await this.#elementWorkspaceContext.reload();
         await this.#loadAndProcessLastPublished();
+        this.referenceCount.clear();
     }
     /**
      * Schedule the element for publishing
@@ -141,6 +163,7 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
         if (!entityType)
             throw new Error('Entity type is missing');
         const { options, selected } = await this.#determineVariantOptions();
+        const entitiesNeedingAttention = await this.#resolveEntitiesNeedingAttention();
         const result = await umbOpenModal(this, UMB_ELEMENT_SCHEDULE_MODAL, {
             data: {
                 options,
@@ -153,6 +176,10 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
                         unpublishTime: option.variant?.scheduledUnpublishDate,
                     },
                 })),
+                unique,
+                itemRepositoryAlias: UMB_ELEMENT_ITEM_REPOSITORY_ALIAS,
+                referenceRepositoryAlias: UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS,
+                entitiesNeedingAttention,
             },
         }).catch(() => undefined);
         if (!result?.selection.length)
@@ -167,7 +194,10 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
         })) ?? [];
         if (!variants.length)
             return;
-        const variantIds = variants.map((x) => x.variantId);
+        let variantIds = variants.map((x) => x.variantId);
+        if (this.#elementWorkspaceContext.getVariesBySegment()) {
+            variantIds = umbExpandVariantIdsWithSegmentOptions(variantIds, await this.#elementWorkspaceContext.getVariantOptions());
+        }
         const saveData = await this.#elementWorkspaceContext.constructSaveData(variantIds);
         await this.#elementWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#elementWorkspaceContext.askServerToValidate(saveData, variantIds);
@@ -189,6 +219,7 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
                 this.#notificationContext?.peek('positive', notification);
                 // reload the element so all states are updated after the schedule operation
                 await this.#elementWorkspaceContext.reload();
+                this.referenceCount.clear();
                 // request reload of this entity
                 const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
                 this.#eventContext?.dispatchEvent(structureEvent);
@@ -235,21 +266,29 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
             throw new Error('Unique is missing');
         let variantIds = [];
         const { options, selected } = await this.#determineVariantOptions();
-        // If there is only one variant, we don't need to open the modal.
         if (options.length === 0) {
             throw new Error('No variants are available');
         }
-        else if (options.length === 1) {
-            // If only one option we will skip ahead and save the element with the only variant available:
+        // Skip the confirmation dialog only when it would have nothing to say: a single variant that may be published,
+        // no items referencing this element, and no referenced element left unpublished. Otherwise open it — the modal
+        // lets the user pick which variants to publish, shows the ones that may not be, and (for a single option) just
+        // the reference sections.
+        const entitiesNeedingAttention = await this.#resolveEntitiesNeedingAttention();
+        const needsModal = !this.#publishableVariantsFilter(options[0]) ||
+            (await umbNeedsPublishConfirmation(options.length, () => this.#getReferenceCount(), entitiesNeedingAttention.length));
+        if (!needsModal) {
             variantIds.push(UmbVariantId.Create(options[0]));
         }
         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_CONTENT_PUBLISH_MODAL, {
                 data: {
                     headline: this.#localize.term('content_saveAndPublishModalTitle'),
                     options,
                     pickableFilter: (option) => this.#publishableVariantsFilter(option),
+                    unique,
+                    itemRepositoryAlias: UMB_ELEMENT_ITEM_REPOSITORY_ALIAS,
+                    referenceRepositoryAlias: UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS,
+                    entitiesNeedingAttention,
                 },
                 value: { selection: selected },
             }).catch(() => undefined);
@@ -259,6 +298,9 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
         }
         // User has committed to publishing (modal closed with a selection, or no modal needed).
         notifyWorkspaceActionStarting(executionOptions);
+        if (this.#elementWorkspaceContext.getVariesBySegment()) {
+            variantIds = umbExpandVariantIdsWithSegmentOptions(variantIds, await this.#elementWorkspaceContext.getVariantOptions());
+        }
         const saveData = await this.#elementWorkspaceContext.constructSaveData(variantIds);
         await this.#elementWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#elementWorkspaceContext.askServerToValidate(saveData, variantIds);
@@ -285,6 +327,25 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
             return await Promise.reject(reason);
         });
     }
+    /**
+     * The number of items referencing this element. A never-saved element has no server-side references yet.
+     * @returns {Promise<number>} The reference count.
+     */
+    async #getReferenceCount() {
+        if (this.#elementWorkspaceContext?.getIsNew())
+            return 0;
+        return this.referenceCount.getTotalAsync();
+    }
+    /**
+     * Resolves the entities this element's current draft directly references that need attention before publishing.
+     * @returns {Promise<Array<UmbEntityModel>>} The referenced entities needing attention.
+     */
+    async #resolveEntitiesNeedingAttention() {
+        const values = this.#elementWorkspaceContext?.getData()?.values ?? [];
+        if (!values.length)
+            return [];
+        return this.#referencedEntities.getEntitiesNeedingAttention(values);
+    }
     async #performSaveAndPublish(variantIds, saveData) {
         await this.#init;
         if (!this.#elementWorkspaceContext)
@@ -340,6 +401,7 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
             });
         }
         await this.#loadAndProcessLastPublished();
+        this.referenceCount.clear();
         const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
         this.#eventContext?.dispatchEvent(event);
     }
@@ -348,13 +410,13 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
         await this.#init;
         if (!this.#elementWorkspaceContext)
             throw new Error('Element workspace context is missing');
-        const allOptions = await firstValueFrom(this.#elementWorkspaceContext.variantOptions);
+        const allOptions = await this.#elementWorkspaceContext.getVariantOptions();
         const options = allOptions.filter((option) => option.segment === null);
         let selected = this.#getPublishVariantsSelection();
         // Selected can contain entries that are not part of the options, therefor filter based on options.
         selected = selected.filter((x) => options.some((o) => o.unique === x));
-        // Filter out read-only variants
-        selected = selected.filter((x) => this.#elementWorkspaceContext.readOnlyGuard.getIsPermittedForVariant(new UmbVariantId(x)) === false);
+        // Filter out variants that cannot be written
+        selected = selected.filter((x) => this.#elementWorkspaceContext.getIsWritableVariant(new UmbVariantId(x)));
         return {
             options,
             selected,
@@ -384,6 +446,7 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase {
                 this.#clear();
             }
             this.#currentUnique = unique;
+            this.referenceCount.setUnique(unique ?? undefined).catch(() => undefined);
             if (isNew === false && unique) {
                 this.#loadAndProcessLastPublished();
             }

package/dist-cms/packages/elements/publishing/workspace-context/needs-publish-confirmation.function.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether the publish confirmation dialog has anything to say: either there is more than one variant to choose
+ * between, the entity being published references entities that need attention, or something references the entity
+ * being published. A failed reference-count lookup is treated as "has references", so the dialog is shown rather
+ * than risking a silent publish past references that couldn't be checked for.
+ * @param {number} variantOptionCount - The number of variant options being published.
+ * @param {() => Promise<number>} getReferenceCount - Resolves the number of items referencing the entity.
+ * @param {number} entitiesNeedingAttentionCount - The number of entities the entity being published references that need attention before publishing.
+ * @returns {Promise<boolean>} Whether the confirmation dialog should be shown.
+ */
+export declare function umbNeedsPublishConfirmation(variantOptionCount: number, getReferenceCount: () => Promise<number>, entitiesNeedingAttentionCount?: number): Promise<boolean>;

package/dist-cms/packages/elements/publishing/workspace-context/needs-publish-confirmation.function.js

@@ -0,0 +1,22 @@
+/**
+ * Whether the publish confirmation dialog has anything to say: either there is more than one variant to choose
+ * between, the entity being published references entities that need attention, or something references the entity
+ * being published. A failed reference-count lookup is treated as "has references", so the dialog is shown rather
+ * than risking a silent publish past references that couldn't be checked for.
+ * @param {number} variantOptionCount - The number of variant options being published.
+ * @param {() => Promise<number>} getReferenceCount - Resolves the number of items referencing the entity.
+ * @param {number} entitiesNeedingAttentionCount - The number of entities the entity being published references that need attention before publishing.
+ * @returns {Promise<boolean>} Whether the confirmation dialog should be shown.
+ */
+export async function umbNeedsPublishConfirmation(variantOptionCount, getReferenceCount, entitiesNeedingAttentionCount = 0) {
+    if (variantOptionCount > 1)
+        return true;
+    if (entitiesNeedingAttentionCount > 0)
+        return true;
+    try {
+        return (await getReferenceCount()) > 0;
+    }
+    catch {
+        return true;
+    }
+}

package/dist-cms/packages/elements/recycle-bin/collection/views/trashed-element-name-table-column.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbTrashedElementNameTableColumnElement extends UmbLitEleme
     set value(value: UmbElementRecycleBinTreeItemModel);
     get value(): UmbElementRecycleBinTreeItemModel;
     constructor();
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 declare global {

package/dist-cms/packages/elements/repository/detail/element-detail-response.mappers.js

@@ -21,7 +21,6 @@ export function umbMapElementResponseToDetailModel(data) {
         variants: data.variants.map((variant) => {
             return {
                 culture: variant.culture || null,
-                segment: variant.segment || null,
                 state: variant.state,
                 name: variant.name,
                 publishDate: variant.publishDate || null,

package/dist-cms/packages/elements/repository/detail/element-detail.repository.d.ts

@@ -2,7 +2,16 @@ import type { UmbElementDetailModel } from '../../types.js';
 import { UmbElementServerDataSource } from './element-detail.server.data-source.js';
 import { UmbDetailRepositoryBase } from '../../../core/repository/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import type { UmbRepositoryResponseWithAsObservable } from '../../../core/repository/index.js';
 export declare class UmbElementDetailRepository extends UmbDetailRepositoryBase<UmbElementDetailModel, UmbElementServerDataSource> {
+    #private;
     constructor(host: UmbControllerHost);
+    /**
+     * Requests multiple element details by their unique IDs
+     * @param {Array<string>} uniques - The unique IDs of the elements to fetch
+     * @returns {Promise<UmbRepositoryResponseWithAsObservable<Array<UmbElementDetailModel> | undefined>>}
+     * @memberof UmbElementDetailRepository
+     */
+    requestByUniques(uniques: Array<string>): Promise<UmbRepositoryResponseWithAsObservable<Array<UmbElementDetailModel> | undefined>>;
 }
 export { UmbElementDetailRepository as api };