@umbraco-cms/backoffice 15.2.3 → 15.3.0-rc2

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

@@ -0,0 +1,14 @@
+import { UMB_DOCUMENT_ENTITY_TYPE } from '../../../entity.js';
+import { UMB_DOCUMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE } from '../../constants.js';
+export const manifests = [
+    {
+        type: 'treeItem',
+        kind: 'recycleBin',
+        alias: 'Umb.TreeItem.Document.RecycleBin',
+        name: 'Document Recycle Bin Tree Item',
+        forEntityTypes: [UMB_DOCUMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE],
+        meta: {
+            supportedEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
+        },
+    },
+];

package/dist-cms/packages/documents/documents/reference/components/document-reference-table.element.js

@@ -37,6 +37,8 @@ let UmbDocumentReferenceTableElement = class UmbDocumentReferenceTableElement ex
         }
         if (!data)
             return;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        //@ts-ignore
         this._items = data.items;
         this._hasMoreReferences = data.total > this.#pageSize ? data.total - this.#pageSize : 0;
     }

package/dist-cms/packages/documents/documents/reference/info-app/document-references-workspace-view-info.element.d.ts

@@ -0,0 +1,17 @@
+import { nothing } from '../../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+export declare class UmbDocumentReferencesWorkspaceInfoAppElement extends UmbLitElement {
+    #private;
+    private _currentPage;
+    private _total;
+    private _items?;
+    constructor();
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default UmbDocumentReferencesWorkspaceInfoAppElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-document-references-workspace-info-app': UmbDocumentReferencesWorkspaceInfoAppElement;
+    }
+}

package/dist-cms/packages/documents/documents/reference/info-app/document-references-workspace-view-info.element.js

@@ -0,0 +1,126 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { UmbDocumentReferenceRepository } from '../repository/index.js';
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from '../../constants.js';
+import { css, customElement, html, nothing, repeat, state } from '../../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import { UmbTextStyles } from '../../../../core/style/index.js';
+let UmbDocumentReferencesWorkspaceInfoAppElement = class UmbDocumentReferencesWorkspaceInfoAppElement extends UmbLitElement {
+    #itemsPerPage;
+    #referenceRepository;
+    #documentUnique;
+    #workspaceContext;
+    constructor() {
+        super();
+        this._currentPage = 1;
+        this._total = 0;
+        this._items = [];
+        this.#itemsPerPage = 10;
+        this.#referenceRepository = new UmbDocumentReferenceRepository(this);
+        this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, (context) => {
+            this.#workspaceContext = context;
+            this.#observeDocumentUnique();
+        });
+    }
+    #observeDocumentUnique() {
+        this.observe(this.#workspaceContext?.unique, (unique) => {
+            if (!unique) {
+                this.#documentUnique = undefined;
+                this._items = [];
+                return;
+            }
+            if (this.#documentUnique === unique) {
+                return;
+            }
+            this.#documentUnique = unique;
+            this.#getReferences();
+        }, 'umbReferencesDocumentUniqueObserver');
+    }
+    async #getReferences() {
+        if (!this.#documentUnique) {
+            throw new Error('Document unique is required');
+        }
+        const { data } = await this.#referenceRepository.requestReferencedBy(this.#documentUnique, (this._currentPage - 1) * this.#itemsPerPage, this.#itemsPerPage);
+        if (!data)
+            return;
+        this._total = data.total;
+        this._items = data.items;
+    }
+    #onPageChange(event) {
+        if (this._currentPage === event.target.current)
+            return;
+        this._currentPage = event.target.current;
+        this.#getReferences();
+    }
+    render() {
+        if (!this._items?.length)
+            return nothing;
+        return html `
+			<umb-workspace-info-app-layout headline="#references_labelUsedByItems">
+				${this.#renderItems()} ${this.#renderReferencePagination()}
+			</umb-workspace-info-app-layout>
+		`;
+    }
+    #renderItems() {
+        if (!this._items)
+            return;
+        return html `
+			<uui-ref-list>
+				${repeat(this._items, (item) => item.unique, (item) => html `<umb-entity-item-ref .item=${item}></umb-entity-item-ref>`)}
+			</uui-ref-list>
+		`;
+    }
+    #renderReferencePagination() {
+        if (!this._total)
+            return nothing;
+        const totalPages = Math.ceil(this._total / this.#itemsPerPage);
+        if (totalPages <= 1)
+            return nothing;
+        return html `
+			<div class="pagination">
+				<uui-pagination .total=${totalPages} @change="${this.#onPageChange}"></uui-pagination>
+			</div>
+		`;
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			:host {
+				display: contents;
+			}
+
+			uui-table-cell:not(.link-cell) {
+				color: var(--uui-color-text-alt);
+			}
+
+			uui-pagination {
+				flex: 1;
+				display: inline-block;
+			}
+
+			.pagination {
+				display: flex;
+				justify-content: center;
+				margin-top: var(--uui-size-space-4);
+			}
+		`,
+    ]; }
+};
+__decorate([
+    state()
+], UmbDocumentReferencesWorkspaceInfoAppElement.prototype, "_currentPage", void 0);
+__decorate([
+    state()
+], UmbDocumentReferencesWorkspaceInfoAppElement.prototype, "_total", void 0);
+__decorate([
+    state()
+], UmbDocumentReferencesWorkspaceInfoAppElement.prototype, "_items", void 0);
+UmbDocumentReferencesWorkspaceInfoAppElement = __decorate([
+    customElement('umb-document-references-workspace-info-app')
+], UmbDocumentReferencesWorkspaceInfoAppElement);
+export { UmbDocumentReferencesWorkspaceInfoAppElement };
+export default UmbDocumentReferencesWorkspaceInfoAppElement;

package/dist-cms/packages/documents/documents/reference/info-app/manifests.js

@@ -0,0 +1,17 @@
+import { UMB_DOCUMENT_WORKSPACE_ALIAS } from '../../workspace/constants.js';
+import { UMB_WORKSPACE_CONDITION_ALIAS } from '../../../../core/workspace/index.js';
+export const manifests = [
+    {
+        type: 'workspaceInfoApp',
+        name: 'Document References Workspace Info App',
+        alias: 'Umb.WorkspaceInfoApp.Document.References',
+        element: () => import('./document-references-workspace-view-info.element.js'),
+        weight: 90,
+        conditions: [
+            {
+                alias: UMB_WORKSPACE_CONDITION_ALIAS,
+                match: UMB_DOCUMENT_WORKSPACE_ALIAS,
+            },
+        ],
+    },
+];

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

@@ -1,2 +1,3 @@
+import { manifests as infoAppManifests } from './info-app/manifests.js';
 import { manifests as repositoryManifests } from './repository/manifests.js';
-export const manifests = [...repositoryManifests];
+export const manifests = [...infoAppManifests, ...repositoryManifests];

package/dist-cms/packages/documents/documents/reference/repository/document-reference-response.management-api.mapping.d.ts

@@ -0,0 +1,8 @@
+import type { UmbDocumentReferenceModel } from '../types.js';
+import { type DocumentReferenceResponseModel } from '../../../../../external/backend-api/index.js';
+import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
+import type { UmbDataSourceDataMapping } from '../../../../core/repository/index.js';
+export declare class UmbDocumentReferenceResponseManagementApiDataMapping extends UmbControllerBase implements UmbDataSourceDataMapping<DocumentReferenceResponseModel, UmbDocumentReferenceModel> {
+    map(data: DocumentReferenceResponseModel): Promise<UmbDocumentReferenceModel>;
+}
+export { UmbDocumentReferenceResponseManagementApiDataMapping as api };

package/dist-cms/packages/documents/documents/reference/repository/document-reference-response.management-api.mapping.js

@@ -0,0 +1,28 @@
+import { UMB_DOCUMENT_ENTITY_TYPE } from '../../entity.js';
+import { DocumentVariantStateModel, } from '../../../../../external/backend-api/index.js';
+import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
+export class UmbDocumentReferenceResponseManagementApiDataMapping extends UmbControllerBase {
+    async map(data) {
+        return {
+            documentType: {
+                alias: data.documentType.alias,
+                icon: data.documentType.icon,
+                name: data.documentType.name,
+            },
+            entityType: UMB_DOCUMENT_ENTITY_TYPE,
+            id: data.id,
+            name: data.name,
+            published: data.published,
+            // TODO: this is a hardcoded array until the server can return the correct variants array
+            variants: [
+                {
+                    culture: null,
+                    name: data.name ?? '',
+                    state: data.published ? DocumentVariantStateModel.PUBLISHED : null,
+                },
+            ],
+            unique: data.id,
+        };
+    }
+}
+export { UmbDocumentReferenceResponseManagementApiDataMapping as api };

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

@@ -1,8 +1,11 @@
 import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
 import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
-export declare class UmbDocumentReferenceRepository extends UmbControllerBase {
+import type { UmbEntityReferenceRepository } from '../../../../relations/relations/index.js';
+export declare class UmbDocumentReferenceRepository extends UmbControllerBase implements UmbEntityReferenceRepository {
     #private;
     constructor(host: UmbControllerHost);
-    requestReferencedBy(unique: string, skip?: number, take?: number): Promise<import("../../../../core/repository/index.js").UmbDataSourceResponse<import("../../../../../external/backend-api/index.js").PagedIReferenceResponseModel>>;
+    requestReferencedBy(unique: string, skip?: number, take?: number): Promise<import("../../../../core/repository/index.js").UmbDataSourceResponse<import("../../../../core/repository/index.js").UmbPagedModel<import("../../../../relations/relations/index.js").UmbReferenceItemModel>>>;
+    requestAreReferenced(uniques: Array<string>, skip?: number, take?: number): Promise<import("../../../../core/repository/index.js").UmbDataSourceResponse<import("../../../../core/repository/index.js").UmbPagedModel<import("../../../../core/entity/index.js").UmbEntityModel>>>;
+    requestDescendantsWithReferences(unique: string, skip?: number, take?: number): Promise<import("../../../../core/repository/index.js").UmbDataSourceResponse<import("../../../../core/repository/index.js").UmbPagedModel<import("../../../../core/entity/index.js").UmbEntityModel>>>;
 }
 export default UmbDocumentReferenceRepository;

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

@@ -11,5 +11,15 @@ export class UmbDocumentReferenceRepository extends UmbControllerBase {
             throw new Error(`unique is required`);
         return this.#referenceSource.getReferencedBy(unique, skip, take);
     }
+    async requestAreReferenced(uniques, skip = 0, take = 20) {
+        if (!uniques || uniques.length === 0)
+            throw new Error(`uniques is required`);
+        return this.#referenceSource.getAreReferenced(uniques, skip, take);
+    }
+    async requestDescendantsWithReferences(unique, skip = 0, take = 20) {
+        if (!unique)
+            throw new Error(`unique is required`);
+        return this.#referenceSource.getReferencedDescendants(unique, skip, take);
+    }
 }
 export default UmbDocumentReferenceRepository;

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

@@ -1,21 +1,38 @@
-import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
+import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
+import type { UmbEntityModel } from '../../../../core/entity/index.js';
+import type { UmbEntityReferenceDataSource, UmbReferenceItemModel } from '../../../../relations/relations/index.js';
+import type { UmbPagedModel, UmbDataSourceResponse } from '../../../../core/repository/index.js';
 /**
  * @class UmbDocumentReferenceServerDataSource
- * @implements {RepositoryDetailDataSource}
+ * @implements {UmbEntityReferenceDataSource}
  */
-export declare class UmbDocumentReferenceServerDataSource {
+export declare class UmbDocumentReferenceServerDataSource extends UmbControllerBase implements UmbEntityReferenceDataSource {
     #private;
     /**
-     * Creates an instance of UmbDocumentReferenceServerDataSource.
-     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
+     * Fetches the item for the given unique from the server
+     * @param {string} unique - The unique identifier of the item to fetch
+     * @param {number} skip - The number of items to skip
+     * @param {number} take - The number of items to take
+     * @returns {Promise<UmbDataSourceResponse<UmbPagedModel<UmbReferenceItemModel>>>} - Items that are referenced by the given unique
      * @memberof UmbDocumentReferenceServerDataSource
      */
-    constructor(host: UmbControllerHost);
+    getReferencedBy(unique: string, skip?: number, take?: number): Promise<UmbDataSourceResponse<UmbPagedModel<UmbReferenceItemModel>>>;
     /**
-     * Fetches the item for the given unique from the server
-     * @param {string} id
-     * @returns {*}
+     * Checks if the items are referenced by other items
+     * @param {Array<string>} uniques - The unique identifiers of the items to fetch
+     * @param {number} skip - The number of items to skip
+     * @param {number} take - The number of items to take
+     * @returns {Promise<UmbDataSourceResponse<UmbPagedModel<UmbEntityModel>>>} - Items that are referenced by other items
+     * @memberof UmbDocumentReferenceServerDataSource
+     */
+    getAreReferenced(uniques: Array<string>, skip?: number, take?: number): Promise<UmbDataSourceResponse<UmbPagedModel<UmbEntityModel>>>;
+    /**
+     * Returns any descendants of the given unique that is referenced by other items
+     * @param {string} unique - The unique identifier of the item to fetch descendants for
+     * @param {number} skip - The number of items to skip
+     * @param {number} take - The number of items to take
+     * @returns {Promise<UmbDataSourceResponse<UmbPagedModel<UmbEntityModel>>>} - Any descendants of the given unique that is referenced by other items
      * @memberof UmbDocumentReferenceServerDataSource
      */
-    getReferencedBy(id: string, skip?: number, take?: number): Promise<import("../../../../core/repository/index.js").UmbDataSourceResponse<import("src/external/backend-api/src").PagedIReferenceResponseModel>>;
+    getReferencedDescendants(unique: string, skip?: number, take?: number): Promise<UmbDataSourceResponse<UmbPagedModel<UmbEntityModel>>>;
 }

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

@@ -1,26 +1,83 @@
+import { UMB_DOCUMENT_ENTITY_TYPE } from '../../entity.js';
 import { DocumentService } from '../../../../../external/backend-api/index.js';
 import { tryExecuteAndNotify } from '../../../../core/resources/index.js';
+import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
+import { UmbManagementApiDataMapper } from '../../../../core/repository/index.js';
 /**
  * @class UmbDocumentReferenceServerDataSource
- * @implements {RepositoryDetailDataSource}
+ * @implements {UmbEntityReferenceDataSource}
  */
-export class UmbDocumentReferenceServerDataSource {
-    #host;
+export class UmbDocumentReferenceServerDataSource extends UmbControllerBase {
+    #dataMapper = new UmbManagementApiDataMapper(this);
     /**
-     * Creates an instance of UmbDocumentReferenceServerDataSource.
-     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
+     * Fetches the item for the given unique from the server
+     * @param {string} unique - The unique identifier of the item to fetch
+     * @param {number} skip - The number of items to skip
+     * @param {number} take - The number of items to take
+     * @returns {Promise<UmbDataSourceResponse<UmbPagedModel<UmbReferenceItemModel>>>} - Items that are referenced by the given unique
      * @memberof UmbDocumentReferenceServerDataSource
      */
-    constructor(host) {
-        this.#host = host;
+    async getReferencedBy(unique, skip = 0, take = 20) {
+        const { data, error } = await tryExecuteAndNotify(this, DocumentService.getDocumentByIdReferencedBy({ id: unique, skip, take }));
+        if (data) {
+            const promises = data.items.map(async (item) => {
+                return this.#dataMapper.map({
+                    forDataModel: item.$type,
+                    data: item,
+                    fallback: async () => {
+                        return {
+                            ...item,
+                            unique: item.id,
+                            entityType: 'unknown',
+                        };
+                    },
+                });
+            });
+            const items = await Promise.all(promises);
+            return { data: { items, total: data.total } };
+        }
+        return { data, error };
     }
     /**
-     * Fetches the item for the given unique from the server
-     * @param {string} id
-     * @returns {*}
+     * Checks if the items are referenced by other items
+     * @param {Array<string>} uniques - The unique identifiers of the items to fetch
+     * @param {number} skip - The number of items to skip
+     * @param {number} take - The number of items to take
+     * @returns {Promise<UmbDataSourceResponse<UmbPagedModel<UmbEntityModel>>>} - Items that are referenced by other items
+     * @memberof UmbDocumentReferenceServerDataSource
+     */
+    async getAreReferenced(uniques, skip = 0, take = 20) {
+        const { data, error } = await tryExecuteAndNotify(this, DocumentService.getDocumentAreReferenced({ id: uniques, skip, take }));
+        if (data) {
+            const items = data.items.map((item) => {
+                return {
+                    unique: item.id,
+                    entityType: UMB_DOCUMENT_ENTITY_TYPE,
+                };
+            });
+            return { data: { items, total: data.total } };
+        }
+        return { data, error };
+    }
+    /**
+     * Returns any descendants of the given unique that is referenced by other items
+     * @param {string} unique - The unique identifier of the item to fetch descendants for
+     * @param {number} skip - The number of items to skip
+     * @param {number} take - The number of items to take
+     * @returns {Promise<UmbDataSourceResponse<UmbPagedModel<UmbEntityModel>>>} - Any descendants of the given unique that is referenced by other items
      * @memberof UmbDocumentReferenceServerDataSource
      */
-    async getReferencedBy(id, skip = 0, take = 20) {
-        return await tryExecuteAndNotify(this.#host, DocumentService.getDocumentByIdReferencedBy({ id, skip, take }));
+    async getReferencedDescendants(unique, skip = 0, take = 20) {
+        const { data, error } = await tryExecuteAndNotify(this, DocumentService.getDocumentByIdReferencedDescendants({ id: unique, skip, take }));
+        if (data) {
+            const items = data.items.map((item) => {
+                return {
+                    unique: item.id,
+                    entityType: UMB_DOCUMENT_ENTITY_TYPE,
+                };
+            });
+            return { data: { items, total: data.total } };
+        }
+        return { data, error };
     }
 }

package/dist-cms/packages/documents/documents/reference/repository/manifests.js

@@ -1,4 +1,5 @@
 import { UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS } from './constants.js';
+import { UMB_MANAGEMENT_API_DATA_SOURCE_ALIAS } from '../../../../core/repository/index.js';
 export const manifests = [
     {
         type: 'repository',
@@ -6,4 +7,12 @@ export const manifests = [
         name: 'Document Reference Repository',
         api: () => import('./document-reference.repository.js'),
     },
+    {
+        type: 'dataSourceDataMapping',
+        alias: 'Umb.DataSourceDataMapping.ManagementApi.DocumentReferenceResponse',
+        name: 'Document Reference Response Management Api Data Mapping',
+        api: () => import('./document-reference-response.management-api.mapping.js'),
+        forDataSource: UMB_MANAGEMENT_API_DATA_SOURCE_ALIAS,
+        forDataModel: 'DocumentReferenceResponseModel',
+    },
 ];

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

@@ -0,0 +1,25 @@
+import type { UmbDocumentItemVariantModel } from '../item/types.js';
+import type { UmbEntityModel } from '../../../core/entity/index.js';
+import type { TrackedReferenceDocumentTypeModel } from '../../../../external/backend-api/index.js';
+export interface UmbDocumentReferenceModel extends UmbEntityModel {
+    /**
+     * @deprecated use unique instead
+     * @type {string}
+     * @memberof UmbDocumentReferenceModel
+     */
+    id: string;
+    /**
+     * @deprecated use name on the variant array instead
+     * @type {(string | null)}
+     * @memberof UmbDocumentReferenceModel
+     */
+    name?: string | null;
+    /**
+     * @deprecated use state on variant array instead
+     * @type {boolean}
+     * @memberof UmbDocumentReferenceModel
+     */
+    published?: boolean | null;
+    documentType: TrackedReferenceDocumentTypeModel;
+    variants: Array<UmbDocumentItemVariantModel>;
+}

package/dist-cms/packages/documents/documents/reference/types.js

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

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

@@ -1,4 +1,2 @@
 export * from './detail/constants.js';
-export * from './item/constants.js';
-export * from './url/constants.js';
 export * from './validation/constants.js';

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

@@ -1,4 +1,2 @@
 export * from './detail/constants.js';
-export * from './item/constants.js';
-export * from './url/constants.js';
 export * from './validation/constants.js';

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

@@ -94,6 +94,8 @@ export class UmbDocumentServerDataSource {
                     publishDate: variant.publishDate || null,
                     createDate: variant.createDate,
                     updateDate: variant.updateDate,
+                    scheduledPublishDate: variant.scheduledPublishDate || null,
+                    scheduledUnpublishDate: variant.scheduledUnpublishDate || null,
                 };
             }),
             urls: data.urls.map((url) => {

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

@@ -1,6 +1,3 @@
 export { UmbDocumentDetailRepository } from './detail/index.js';
-export { UmbDocumentItemRepository } from './item/index.js';
-export { UmbDocumentUrlRepository, UMB_DOCUMENT_URL_REPOSITORY_ALIAS } from './url/index.js';
 export { UmbDocumentPreviewRepository } from './preview/index.js';
 export * from './constants.js';
-export type * from './types.js';

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

@@ -1,5 +1,3 @@
 export { UmbDocumentDetailRepository } from './detail/index.js';
-export { UmbDocumentItemRepository } from './item/index.js';
-export { UmbDocumentUrlRepository, UMB_DOCUMENT_URL_REPOSITORY_ALIAS } from './url/index.js';
 export { UmbDocumentPreviewRepository } from './preview/index.js';
 export * from './constants.js';

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

@@ -1,4 +1,2 @@
 import { manifests as detailManifests } from './detail/manifests.js';
-import { manifests as itemManifests } from './item/manifests.js';
-import { manifests as urlManifests } from './url/manifests.js';
-export const manifests = [...detailManifests, ...itemManifests, ...urlManifests];
+export const manifests = [...detailManifests];

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

@@ -1,5 +1,4 @@
-import { UMB_USER_PERMISSION_DOCUMENT_ROLLBACK, UMB_DOCUMENT_ENTITY_TYPE, UMB_DOCUMENT_WORKSPACE_ALIAS, } from '../../constants.js';
-import { UMB_WORKSPACE_CONDITION_ALIAS } from '../../../../core/workspace/index.js';
+import { UMB_USER_PERMISSION_DOCUMENT_ROLLBACK, UMB_DOCUMENT_ENTITY_TYPE } from '../../constants.js';
 import { UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS } from '../../../../core/recycle-bin/index.js';
 export const manifests = [
     {
@@ -7,7 +6,7 @@ export const manifests = [
         kind: 'default',
         alias: 'Umb.EntityAction.Document.Rollback',
         name: 'Rollback Document Entity Action',
-        weight: 500,
+        weight: 450,
         api: () => import('./rollback.action.js'),
         forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
         meta: {
@@ -22,12 +21,6 @@ export const manifests = [
             {
                 alias: UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS,
             },
-            /* Currently the rollback is tightly coupled to the workspace contexts so we only allow it to show up
-             In the document workspace. */
-            {
-                alias: UMB_WORKSPACE_CONDITION_ALIAS,
-                match: UMB_DOCUMENT_WORKSPACE_ALIAS,
-            },
         ],
     },
 ];

package/dist-cms/packages/documents/documents/rollback/modal/rollback-modal.element.d.ts

@@ -1,4 +1,5 @@
 import type { UmbRollbackModalData, UmbRollbackModalValue } from './types.js';
+import { type Change } from '../../../../../external/diff/index.js';
 import { UmbModalBaseElement } from '../../../../core/modal/index.js';
 import '../../modals/shared/document-variant-language-picker.element.js';
 type DocumentVersion = {
@@ -10,8 +11,8 @@ type DocumentVersion = {
 };
 export declare class UmbRollbackModalElement extends UmbModalBaseElement<UmbRollbackModalData, UmbRollbackModalValue> {
     #private;
-    versions: DocumentVersion[];
-    currentVersion?: {
+    _versions: DocumentVersion[];
+    _selectedVersion?: {
         date: string;
         name: string;
         user: string;
@@ -21,8 +22,13 @@ export declare class UmbRollbackModalElement extends UmbModalBaseElement<UmbRoll
             value: string;
         }[];
     };
-    currentCulture?: string;
-    availableVariants: Option[];
+    _selectedCulture: string | null;
+    _isInvariant: boolean;
+    _availableVariants: Option[];
+    _diffs: Array<{
+        alias: string;
+        diff: Change[];
+    }>;
     constructor();
     get currentVersionHeader(): string;
     render(): import("lit-html").TemplateResult<1>;