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

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

@@ -2,25 +2,33 @@ import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from '../../workspace/context/document
 import { UmbDocumentPublishingRepository } from '../repository/index.js';
 import { UmbDocumentPublishedPendingChangesManager } from '../pending-changes/index.js';
 import { UMB_DOCUMENT_SCHEDULE_MODAL } from '../schedule-publish/constants.js';
+import { UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS } from '../../reference/repository/constants.js';
+import { UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS } from '../../item/repository/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 { firstValueFrom } from '../../../../../external/rxjs/index.js';
 import { observeMultiple } from '../../../../../libs/observable-api/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 { 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 { UmbRequestReloadChildrenOfEntityEvent, 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 UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
+    /**
+     * Resolves the elements this document directly references (via its draft property values) that are not
+     * fully published, for the same publish-confirmation decision as {@link referenceCount}.
+     * @memberof UmbDocumentPublishingWorkspaceContext
+     */
+    #referencedEntities;
     #init;
     #documentWorkspaceContext;
     #eventContext;
@@ -38,17 +46,28 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
          * @memberof UmbDocumentPublishingWorkspaceContext
          */
         this.publishedPendingChanges = new UmbDocumentPublishedPendingChangesManager(this);
+        /**
+         * Tracks how many items reference this document, so the publish flow can decide whether the confirmation
+         * dialog has anything to say for a single-variant document (it always has something to say once there are
+         * multiple variants to choose between). Loaded lazily, at the point of publishing/scheduling.
+         * @memberof UmbDocumentPublishingWorkspaceContext
+         */
+        this.referenceCount = new UmbEntityReferenceCountManager(this, {
+            referenceRepositoryAlias: UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS,
+            prefetch: false,
+        });
+        /**
+         * Resolves the elements this document directly references (via its draft property values) that are not
+         * fully published, for the same publish-confirmation decision as {@link referenceCount}.
+         * @memberof UmbDocumentPublishingWorkspaceContext
+         */
+        this.#referencedEntities = new UmbContentReferencedEntitiesManager(this);
         this.#publishingRepository = new UmbDocumentPublishingRepository(this);
         this.#loadingPublishedData = false;
         this.#localize = new UmbLocalizationController(this);
         this.workspaceAlias = UMB_DOCUMENT_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.#documentWorkspaceContext.readOnlyGuard.getIsPermittedForVariant(variantId);
-            // If the variant is read only, we can't publish it
-            const isPublishable = !isReadOnly;
-            return isPublishable;
+            return this.#documentWorkspaceContext.getIsWritableVariant(UmbVariantId.Create(option));
         };
         this.#init = Promise.all([
             this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, async (context) => {
@@ -116,14 +135,13 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         const unique = this.#documentWorkspaceContext.getUnique();
         if (!unique)
             throw new Error('Unique is missing');
-        const entityType = this.#documentWorkspaceContext.getEntityType();
-        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_DOCUMENT_SCHEDULE_MODAL, {
             data: {
                 options,
                 activeVariants: selected,
+                currentVariant: this.#getCurrentScheduleVariant(options),
                 pickableFilter: this.#publishableVariantsFilter,
                 prevalues: options.map((option) => ({
                     unique: option.unique,
@@ -132,47 +150,32 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                         unpublishTime: option.variant?.scheduledUnpublishDate,
                     },
                 })),
+                unique,
+                itemRepositoryAlias: UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS,
+                referenceRepositoryAlias: UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS,
+                entitiesNeedingAttention,
             },
         }).catch(() => undefined);
         if (!result?.selection.length)
             return;
         // Map to the correct format for the API (UmbDocumentVariantPublishModel)
-        const variants = result?.selection.map((x) => ({
+        const cultureVariants = result?.selection.map((x) => ({
             variantId: UmbVariantId.FromString(x.unique),
             schedule: {
                 publishTime: this.#convertToDateTimeOffset(x.schedule?.publishTime),
                 unpublishTime: this.#convertToDateTimeOffset(x.schedule?.unpublishTime),
             },
         })) ?? [];
-        if (!variants.length)
+        if (!cultureVariants.length)
             return;
-        const variantIds = variants.map((x) => x.variantId);
+        let variantIds = cultureVariants.map((x) => x.variantId);
+        variantIds = umbExpandVariantIdsWithSegmentOptions(variantIds, await this.#documentWorkspaceContext.getVariantOptions());
         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 () => {
             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);
+                await this.#performSchedule(variantIds, cultureVariants, saveData);
             }
             catch (error) {
                 // Notify only on the publish path. The validation-failure path below already
@@ -193,6 +196,36 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             return Promise.reject(reason);
         });
     }
+    async #performSchedule(variantIds, variants, saveData) {
+        if (!this.#documentWorkspaceContext) {
+            throw new Error('Document workspace context is missing');
+        }
+        const unique = this.#documentWorkspaceContext.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        const entityType = this.#documentWorkspaceContext.getEntityType();
+        if (!entityType)
+            throw new Error('Entity type 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();
+        this.referenceCount.clear();
+        // request reload of this entity
+        const structureEvent = new UmbRequestReloadStructureForEntityEvent({ entityType, unique });
+        this.#eventContext?.dispatchEvent(structureEvent);
+    }
     /**
      * 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.
@@ -238,10 +271,11 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         if (!result?.selection.length)
             return;
         // Map to variantIds
-        const variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
+        let variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
         if (!variantIds.length)
             return;
         const workspaceContext = this.#documentWorkspaceContext;
+        variantIds = umbExpandVariantIdsWithSegmentOptions(variantIds, await workspaceContext.getVariantOptions());
         const saveData = await workspaceContext.constructSaveData(variantIds);
         try {
             await workspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
@@ -376,6 +410,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         // 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();
+        this.referenceCount.clear();
     }
     /**
      * Asks whether to discard unsaved changes, for actions that replace the workspace data.
@@ -395,16 +430,19 @@ export class UmbDocumentPublishingWorkspaceContext 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 document with the only variant available:
+        // Skip the confirmation dialog only when it would have nothing to say: a single variant to publish,
+        // nothing referencing this document, and no referenced element left unpublished. Otherwise open it —
+        // the modal hides the variant picker for an invariant document, showing just the reference sections.
+        const entitiesNeedingAttention = await this.#resolveEntitiesNeedingAttention();
+        const needsModal = await this.#needsPublishConfirmationModal(options, entitiesNeedingAttention);
+        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.
+            // Otherwise the modal lets the user pick which variants to publish, and shows the ones that may not be.
             const result = await umbOpenModal(this, UMB_CONTENT_PUBLISH_MODAL, {
                 data: {
                     headline: this.#localize.term('content_saveAndPublishModalTitle'),
@@ -412,6 +450,10 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                     // 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),
+                    unique,
+                    itemRepositoryAlias: UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS,
+                    referenceRepositoryAlias: UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS,
+                    entitiesNeedingAttention,
                 },
                 value: { selection: selected },
             }).catch(() => undefined);
@@ -421,6 +463,9 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         }
         // User has committed to publishing (modal closed with a selection, or no modal needed).
         notifyWorkspaceActionStarting(executionOptions);
+        if (this.#documentWorkspaceContext.getVariesBySegment()) {
+            variantIds = umbExpandVariantIdsWithSegmentOptions(variantIds, await this.#documentWorkspaceContext.getVariantOptions());
+        }
         const saveData = await this.#documentWorkspaceContext.constructSaveData(variantIds);
         await this.#documentWorkspaceContext.runMandatoryValidationForSaveData(saveData, variantIds);
         await this.#documentWorkspaceContext.askServerToValidate(saveData, variantIds);
@@ -437,6 +482,41 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             });
         }, (reason) => this.#saveWithoutPublishing(variantIds, saveData, reason));
     }
+    /**
+     * Whether the publish confirmation modal has anything to say: either there is more than one variant to choose
+     * between (or the only one can't be published), something references this document, or this document references an entity that needs attention.
+     * @param {Array<UmbDocumentVariantOptionModel>} options - The variant options being published.
+     * @param {Array<UmbEntityModel>} entitiesNeedingAttention - Entities this document references that need attention before publishing.
+     * @returns {Promise<boolean>} Whether the confirmation modal should be shown.
+     */
+    async #needsPublishConfirmationModal(options, entitiesNeedingAttention) {
+        if (options.length > 1 || !this.#publishableVariantsFilter(options[0]))
+            return true;
+        // Resolved from draft values, so it applies to a never-saved document too — unlike referencedBy below.
+        if (entitiesNeedingAttention.length > 0)
+            return true;
+        // A document that has never been saved has no server-side references in either direction yet.
+        if (this.#documentWorkspaceContext?.getIsNew())
+            return false;
+        try {
+            return (await this.referenceCount.getTotalAsync()) > 0;
+        }
+        catch {
+            // Couldn't determine the reference count — show the modal rather than risk publishing silently past
+            // references we failed to check for.
+            return true;
+        }
+    }
+    /**
+     * Resolves the entities this document's current draft directly references that need attention before publishing.
+     * @returns {Promise<Array<UmbEntityModel>>} The referenced entities needing attention.
+     */
+    async #resolveEntitiesNeedingAttention() {
+        const values = this.#documentWorkspaceContext?.getData()?.values ?? [];
+        if (!values.length)
+            return [];
+        return this.#referencedEntities.getEntitiesNeedingAttention(values);
+    }
     async #performSaveAndPublish(variantIds, saveData) {
         await this.#init;
         if (!this.#documentWorkspaceContext)
@@ -492,6 +572,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
             });
         }
         await this.#loadAndProcessLastPublished();
+        this.referenceCount.clear();
         // Re-read the unique: for a new document, the server may have assigned a different one than the
         // workspace scaffolded with, and `performCreateOrUpdate` above will have re-synced it if so.
         const persistedUnique = this.#documentWorkspaceContext.getUnique() ?? unique;
@@ -503,22 +584,34 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
         await this.#init;
         if (!this.#documentWorkspaceContext)
             throw new Error('Document workspace context is missing');
-        const allOptions = await firstValueFrom(this.#documentWorkspaceContext.variantOptions);
+        const allOptions = await this.#documentWorkspaceContext.getVariantOptions();
         const options = allOptions.filter((option) => option.segment === null);
         // TODO: this is a temporary copy of the content-detail workspace context method.
         // we need to implement custom selection that makes sense for each the publishing modal.
         let selected = this.#getPublishVariantsSelection();
         // Selected can contain entries that are not part of the options, therefor the modal filters selection based on options.
         selected = selected.filter((x) => options.some((o) => o.unique === x));
-        // Filter out read-only variants
+        // Filter out variants that cannot be written
         // TODO: This would not work with segments, as the 'selected'-array is an array of strings, not UmbVariantId's. [NL]
         // Please have a look at the implementation in the content-detail workspace context, as that one compares variantIds. [NL]
-        selected = selected.filter((x) => this.#documentWorkspaceContext.readOnlyGuard.getIsPermittedForVariant(new UmbVariantId(x)) === false);
+        selected = selected.filter((x) => this.#documentWorkspaceContext.getIsWritableVariant(new UmbVariantId(x)));
         return {
             options,
             selected,
         };
     }
+    #getCurrentScheduleVariant(options) {
+        if (!this.#documentWorkspaceContext)
+            throw new Error('Document workspace context is missing');
+        // The schedule dialog lists cultures only, so an active segment variant resolves to its culture.
+        const activeCultures = this.#documentWorkspaceContext.splitView
+            .getActiveVariants()
+            .map((x) => UmbVariantId.Create(x).toSegmentInvariant().toString());
+        return activeCultures.find((unique) => {
+            const option = options.find((o) => o.unique === unique);
+            return !!option && this.#publishableVariantsFilter(option);
+        });
+    }
     #getPublishVariantsSelection() {
         if (!this.#documentWorkspaceContext)
             throw new Error('Document workspace context is missing');
@@ -545,6 +638,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase {
                 this.#clear();
             }
             this.#currentUnique = unique;
+            this.referenceCount.setUnique(unique ?? undefined).catch(() => undefined);
             if (isNew === false && unique) {
                 this.#loadAndProcessLastPublished().catch(() => undefined);
             }

package/dist-cms/packages/documents/documents/recycle-bin/tree/tree-item-children/collection/views/trashed-document-name-table-column.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbTrashedDocumentNameTableColumnElement extends UmbLitElem
     set value(value: UmbDocumentRecycleBinTreeItemModel);
     get value(): UmbDocumentRecycleBinTreeItemModel;
     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/documents/documents/redirect-management/info-app/document-redirect-management-workspace-info-app.element.d.ts

@@ -8,7 +8,7 @@ export declare class UmbDocumentRedirectManagementWorkspaceInfoAppElement extend
     private _trackerEnabled;
     private _unique?;
     constructor();
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
     disconnectedCallback(): void;
     static styles: import("lit").CSSResult[];
 }

package/dist-cms/packages/documents/documents/redirect-management/repository/document-redirect-management.repository.d.ts

@@ -15,16 +15,6 @@ export declare class UmbDocumentRedirectManagementRepository extends UmbControll
      * @memberof UmbDocumentRedirectManagementRepository
      */
     requestStatus(): Promise<UmbRepositoryResponse<UmbDocumentRedirectStatusModel>>;
-    /**
-     * Enables or disables the redirect URL tracker.
-     * @param {boolean} enabled - Whether the tracker should be enabled.
-     * @returns {Promise<UmbRepositoryErrorResponse>} Undefined if the operation succeeded, otherwise an error.
-     * @memberof UmbDocumentRedirectManagementRepository
-     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
-     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
-     *   Scheduled for removal in Umbraco 19.
-     */
-    setStatus(enabled: boolean): Promise<UmbRepositoryErrorResponse>;
     /**
      * Gets the redirects pointing to a specific document.
      * @param {string} unique - The document unique identifier.

package/dist-cms/packages/documents/documents/redirect-management/repository/document-redirect-management.repository.js

@@ -1,6 +1,5 @@
 import { UmbDocumentRedirectManagementServerDataSource } from './document-redirect-management.server.data-source.js';
 import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
-import { UmbDeprecation } from '../../../../core/utils/index.js';
 /**
  * Repository for managing document redirect URLs.
  * @class UmbDocumentRedirectManagementRepository
@@ -16,23 +15,6 @@ export class UmbDocumentRedirectManagementRepository extends UmbControllerBase {
     async requestStatus() {
         return this.#dataSource.getStatus();
     }
-    /**
-     * Enables or disables the redirect URL tracker.
-     * @param {boolean} enabled - Whether the tracker should be enabled.
-     * @returns {Promise<UmbRepositoryErrorResponse>} Undefined if the operation succeeded, otherwise an error.
-     * @memberof UmbDocumentRedirectManagementRepository
-     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
-     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
-     *   Scheduled for removal in Umbraco 19.
-     */
-    async setStatus(enabled) {
-        new UmbDeprecation({
-            deprecated: 'UmbDocumentRedirectManagementRepository.setStatus()',
-            removeInVersion: '19.0.0',
-            solution: 'The backend endpoint is now a no-op. Set the Umbraco:CMS:WebRouting:DisableRedirectUrlTracking configuration key instead.',
-        }).warn();
-        return this.#dataSource.setStatus(enabled);
-    }
     /**
      * Gets the redirects pointing to a specific document.
      * @param {string} unique - The document unique identifier.

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

@@ -19,16 +19,6 @@ export declare class UmbDocumentRedirectManagementServerDataSource {
      * @memberof UmbDocumentRedirectManagementServerDataSource
      */
     getStatus(): Promise<UmbDataSourceResponse<UmbDocumentRedirectStatusModel>>;
-    /**
-     * Enables or disables the redirect URL tracker.
-     * @param {boolean} enabled - Whether the tracker should be enabled.
-     * @returns {Promise<UmbDataSourceErrorResponse>} Undefined if the operation succeeded, otherwise an error.
-     * @memberof UmbDocumentRedirectManagementServerDataSource
-     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
-     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
-     *   Scheduled for removal in Umbraco 19.
-     */
-    setStatus(enabled: boolean): Promise<UmbDataSourceErrorResponse>;
     /**
      * Gets the redirects pointing to a specific document.
      * @param {string} unique - The document unique identifier.

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

@@ -29,20 +29,6 @@ export class UmbDocumentRedirectManagementServerDataSource {
         };
         return { data: model };
     }
-    /**
-     * Enables or disables the redirect URL tracker.
-     * @param {boolean} enabled - Whether the tracker should be enabled.
-     * @returns {Promise<UmbDataSourceErrorResponse>} Undefined if the operation succeeded, otherwise an error.
-     * @memberof UmbDocumentRedirectManagementServerDataSource
-     * @deprecated Deprecated since v17. The backend endpoint is now a no-op; set the
-     *   `Umbraco:CMS:WebRouting:DisableRedirectUrlTracking` configuration key instead.
-     *   Scheduled for removal in Umbraco 19.
-     */
-    async setStatus(enabled) {
-        const status = enabled ? RedirectStatusModel.ENABLED : RedirectStatusModel.DISABLED;
-        const { error } = await tryExecute(this.#host, RedirectManagementService.postRedirectManagementStatus({ query: { status } }));
-        return { error };
-    }
     /**
      * Gets the redirects pointing to a specific document.
      * @param {string} unique - The document unique identifier.

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

@@ -74,7 +74,6 @@ export class UmbDocumentServerDataSource extends UmbControllerBase {
             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/documents/documents/repository/index.d.ts

@@ -1,4 +1,2 @@
 export { UmbDocumentDetailRepository } from './detail/index.js';
-export { UmbDocumentPreviewRepository } from './preview/index.js';
-export { UmbDocumentSegmentRepository } from './segment/index.js';
 export * from './constants.js';

package/dist-cms/packages/documents/documents/repository/index.js

@@ -1,4 +1,2 @@
 export { UmbDocumentDetailRepository } from './detail/index.js';
-export { UmbDocumentPreviewRepository } from './preview/index.js';
-export { UmbDocumentSegmentRepository } from './segment/index.js';
 export * from './constants.js';

package/dist-cms/packages/documents/documents/repository/types.d.ts

@@ -1 +1 @@
-export type * from './segment/types.js';
+export {};

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

@@ -1,6 +1,6 @@
 import type { UmbDocumentDetailModel } 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 { UmbEntityUnique } from '../../../../core/entity/index.js';
 import type { UmbDataSourceResponse } from '../../../../core/repository/index.js';
 /**

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

@@ -1,5 +1,6 @@
 import { DocumentService, } from '../../../../core/backend-api/index.js';
 import { tryExecute } from '../../../../core/resources/index.js';
+import { umbVariantIdsToCultures } from '../../../../core/variant/index.js';
 /**
  * A server data source for Document Validation
  */
@@ -50,7 +51,7 @@ export class UmbDocumentValidationServerDataSource {
     async validateUpdate(model, variantIds) {
         if (!model.unique)
             throw new Error('Unique is missing');
-        const cultures = variantIds.map((id) => id.culture).filter((culture) => culture !== null);
+        const cultures = umbVariantIdsToCultures(variantIds).filter((x) => x !== null);
         // TODO: make data mapper to prevent errors
         const body = {
             template: model.template ? { id: model.template.unique } : null,

package/dist-cms/packages/documents/documents/rollback/constants.d.ts

@@ -1,2 +1 @@
-export { UMB_ROLLBACK_MODAL_ALIAS, UMB_ROLLBACK_MODAL } from './modal/constants.js';
-export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS, UMB_ROLLBACK_REPOSITORY_ALIAS } from './repository/constants.js';
+export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS } from './repository/constants.js';

package/dist-cms/packages/documents/documents/rollback/constants.js

@@ -1,2 +1 @@
-export { UMB_ROLLBACK_MODAL_ALIAS, UMB_ROLLBACK_MODAL } from './modal/constants.js';
-export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS, UMB_ROLLBACK_REPOSITORY_ALIAS } from './repository/constants.js';
+export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS } from './repository/constants.js';

package/dist-cms/packages/documents/documents/rollback/manifests.js

@@ -1,10 +1,8 @@
 import { manifests as auditLogActionManifests } from './audit-log-action/manifests.js';
 import { manifests as entityActionManifests } from './entity-action/manifests.js';
-import { manifests as modalManifests } from './modal/manifests.js';
 import { manifests as repositoryManifests } from './repository/manifests.js';
 export const manifests = [
     ...auditLogActionManifests,
     ...entityActionManifests,
-    ...modalManifests,
     ...repositoryManifests,
 ];

package/dist-cms/packages/documents/documents/rollback/repository/constants.d.ts

@@ -1,5 +1 @@
 export declare const UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS = "Umb.Repository.Document.Rollback";
-/**
- * @deprecated Use {@link UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS} instead. Scheduled for removal in Umbraco 19.
- */
-export declare const UMB_ROLLBACK_REPOSITORY_ALIAS = "Umb.Repository.Document.Rollback";

package/dist-cms/packages/documents/documents/rollback/repository/constants.js

@@ -1,5 +1 @@
 export const UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS = 'Umb.Repository.Document.Rollback';
-/**
- * @deprecated Use {@link UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS} instead. Scheduled for removal in Umbraco 19.
- */
-export const UMB_ROLLBACK_REPOSITORY_ALIAS = UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS;

package/dist-cms/packages/documents/documents/rollback/repository/index.d.ts

@@ -1,2 +1,2 @@
-export { UmbDocumentRollbackRepository, UmbRollbackRepository } from './rollback.repository.js';
-export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS, UMB_ROLLBACK_REPOSITORY_ALIAS } from './constants.js';
+export { UmbDocumentRollbackRepository } from './rollback.repository.js';
+export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS } from './constants.js';

package/dist-cms/packages/documents/documents/rollback/repository/index.js

@@ -1,2 +1,2 @@
-export { UmbDocumentRollbackRepository, UmbRollbackRepository } from './rollback.repository.js';
-export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS, UMB_ROLLBACK_REPOSITORY_ALIAS } from './constants.js';
+export { UmbDocumentRollbackRepository } from './rollback.repository.js';
+export { UMB_DOCUMENT_ROLLBACK_REPOSITORY_ALIAS } from './constants.js';

package/dist-cms/packages/documents/documents/rollback/repository/rollback.repository.d.ts

@@ -1,8 +1,6 @@
 import type { UmbContentRollbackRepository, UmbContentRollbackVersionDetailModel, UmbContentRollbackVersionItemModel } from '../../../../content/content/index.js';
 import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
 import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
-import type { PagedDocumentVersionItemResponseModel } from '../../../../core/backend-api/index.js';
-import type { UmbRepositoryResponse } from '../../../../core/repository/index.js';
 export declare class UmbDocumentRollbackRepository extends UmbControllerBase implements UmbContentRollbackRepository {
     #private;
     constructor(host: UmbControllerHost);
@@ -27,16 +25,5 @@ export declare class UmbDocumentRollbackRepository extends UmbControllerBase imp
         request: Request;
         response: Response;
     }>>;
-    /**
-     * @param {string} id - The document unique identifier.
-     * @param {string} [culture] - The culture to get versions for.
-     * @returns {UmbRepositoryResponse<PagedDocumentVersionItemResponseModel>} The versions for the document.
-     * @deprecated Use {@link requestVersionsByEntityId} instead. Scheduled for removal in Umbraco 19.
-     */
-    requestVersionsByDocumentId(id: string, culture?: string): Promise<UmbRepositoryResponse<PagedDocumentVersionItemResponseModel>>;
 }
-/**
- * @deprecated Use {@link UmbDocumentRollbackRepository} instead. Scheduled for removal in Umbraco 19.
- */
-export { UmbDocumentRollbackRepository as UmbRollbackRepository };
 export default UmbDocumentRollbackRepository;

package/dist-cms/packages/documents/documents/rollback/repository/rollback.repository.js

@@ -37,6 +37,7 @@ export class UmbDocumentRollbackRepository extends UmbControllerBase {
                     })),
                     values: data.values.map((v) => ({
                         culture: v.culture ?? null,
+                        segment: v.segment ?? null,
                         alias: v.alias,
                         value: v.value,
                     })),
@@ -51,18 +52,5 @@ export class UmbDocumentRollbackRepository extends UmbControllerBase {
     async rollback(versionId, culture) {
         return await this.#dataSource.rollback(versionId, culture);
     }
-    /**
-     * @param {string} id - The document unique identifier.
-     * @param {string} [culture] - The culture to get versions for.
-     * @returns {UmbRepositoryResponse<PagedDocumentVersionItemResponseModel>} The versions for the document.
-     * @deprecated Use {@link requestVersionsByEntityId} instead. Scheduled for removal in Umbraco 19.
-     */
-    async requestVersionsByDocumentId(id, culture) {
-        return await this.#dataSource.getVersionsByDocumentId(id, culture);
-    }
 }
-/**
- * @deprecated Use {@link UmbDocumentRollbackRepository} instead. Scheduled for removal in Umbraco 19.
- */
-export { UmbDocumentRollbackRepository as UmbRollbackRepository };
 export default UmbDocumentRollbackRepository;

package/dist-cms/packages/documents/documents/search/document-search-result-item.element.d.ts

@@ -9,7 +9,7 @@ export declare class UmbDocumentSearchResultItemElement extends UmbLitElement {
     private _defaultCulture?;
     private _variant?;
     constructor();
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 export { UmbDocumentSearchResultItemElement as element };

package/dist-cms/packages/documents/documents/tree/tree-item/document-tree-item.element.d.ts

@@ -19,8 +19,8 @@ export declare class UmbDocumentTreeItemElement extends UmbTreeItemElementBase<U
     protected _renderChildItem(item: UmbDocumentTreeItemModel): import("lit-html").TemplateResult<1>;
     _renderExpandSymbol: () => import("lit-html").TemplateResult<1> | undefined;
     renderLabel(): import("lit-html").TemplateResult<1>;
-    protected _renderLoadPrevButton(): import("lit-html").TemplateResult<1> | typeof nothing;
-    protected _renderLoadNextButton(): import("lit-html").TemplateResult<1> | typeof nothing;
+    protected _renderLoadPrevButton(): typeof nothing | import("lit-html").TemplateResult<1>;
+    protected _renderLoadNextButton(): typeof nothing | import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 export default UmbDocumentTreeItemElement;