@umbraco-cms/backoffice 17.2.2 → 17.3.0-rc

package/dist-cms/packages/block/block-single/components/block-single-entry/block-single-entry.element.js

@@ -76,7 +76,7 @@ let UmbBlockSingleEntryElement = class UmbBlockSingleEntryElement extends UmbLit
         };
         this.#extensionSlotRenderMethod = (ext) => {
             ext.component?.setAttribute('part', 'component');
-            if (this._exposed) {
+            if (this._exposed || this._isReadOnly) {
                 return ext.component;
             }
             else {
@@ -280,6 +280,8 @@ let UmbBlockSingleEntryElement = class UmbBlockSingleEntryElement extends UmbLit
             : nothing;
     }
     #renderEditContentAction() {
+        if (this._isReadOnly)
+            return nothing;
         return this._showContentEdit && this._workspaceEditContentPath
             ? html `<uui-button
 					label="edit"
@@ -301,6 +303,8 @@ let UmbBlockSingleEntryElement = class UmbBlockSingleEntryElement extends UmbLit
                 : nothing;
     }
     #renderEditSettingsAction() {
+        if (this._isReadOnly)
+            return nothing;
         return html `
 			${this._hasSettings && this._workspaceEditSettingsPath
             ? html `<uui-button
@@ -324,9 +328,14 @@ let UmbBlockSingleEntryElement = class UmbBlockSingleEntryElement extends UmbLit
 		</uui-button>`;
     }
     #renderCopyToClipboardAction() {
-        return html `<uui-button label="Copy to clipboard" look="secondary" @click=${() => this.#copyToClipboard()}>
-			<uui-icon name="icon-clipboard-copy"></uui-icon>
-		</uui-button>`;
+        return html `
+			<uui-button
+				label=${this.localize.term('clipboard_labelForCopyToClipboard')}
+				look="secondary"
+				@click=${() => this.#copyToClipboard()}>
+				<uui-icon name="icon-clipboard-copy"></uui-icon>
+			</uui-button>
+		`;
     }
     render() {
         return this.#renderBlock();

package/dist-cms/packages/block/block-single/components/inline-single-block/inline-single-block.element.js

@@ -41,6 +41,7 @@ let UmbInlineSingleBlockElement = class UmbInlineSingleBlockElement extends UmbL
             if (permitted && context) {
                 this.#workspaceContext = context;
                 this.#workspaceContext.establishLiveSync();
+                this.#workspaceContext.autoReportValidation();
                 this.#load();
                 this.observe(this.#workspaceContext.exposed, (exposed) => {
                     this._exposed = exposed;

package/dist-cms/packages/block/block-single/components/ref-single-block/ref-single-block.element.js

@@ -11,7 +11,10 @@ let UmbRefSingleBlockElement = class UmbRefSingleBlockElement extends UmbLitElem
     render() {
         const blockValue = { ...this.content, $settings: this.settings };
         return html `
-			<uui-ref-node standalone href=${(this.config?.showContentEdit ? this.config?.editContentPath : undefined) ?? ''}>
+			<uui-ref-node
+				standalone
+				.readonly=${!(this.config?.showContentEdit ?? false)}
+				.href=${this.config?.showContentEdit ? this.config?.editContentPath : undefined}>
 				<umb-icon slot="icon" .name=${this.icon}></umb-icon>
 				<umb-ufm-render slot="name" inline .markdown=${this.label} .value=${blockValue}></umb-ufm-render>
 				${when(this.unpublished, () => html `<uui-tag slot="name" look="secondary" title=${this.localize.term('blockEditor_notExposedDescription')}

package/dist-cms/packages/block/block-single/context/block-single-entries.context.js

@@ -30,9 +30,16 @@ export class UmbBlockSingleEntriesContext extends UmbBlockEntriesContext {
             }
             const config = propertyContext.getConfig();
             const valueResolver = new UmbClipboardPastePropertyValueTranslatorValueResolver(this);
+            const blockTypes = this._manager.getBlockTypes() ?? [];
+            /*
+            modal size logic:
+            If more than 8 block types, medium modal, more than 12 large modal:
+            */
+            const modalSize = blockTypes.length > 12 ? 'large' : blockTypes.length > 8 ? 'medium' : 'small';
             return {
+                modal: { size: modalSize },
                 data: {
-                    blocks: this._manager?.getBlockTypes() ?? [],
+                    blocks: blockTypes,
                     blockGroups: [],
                     openClipboard: routingInfo.view === 'clipboard',
                     clipboardFilter: async (clipboardEntryDetail) => {
@@ -98,7 +105,18 @@ export class UmbBlockSingleEntriesContext extends UmbBlockEntriesContext {
         }, 'observeThisLayouts');
     }
     getPathForCreateBlock(index) {
-        return this._catalogueRouteBuilderState.getValue()?.({ view: 'create', index: index });
+        const pathBuilder = this._catalogueRouteBuilderState.getValue();
+        if (!pathBuilder)
+            return undefined;
+        if (!this._manager)
+            return undefined;
+        const blockTypes = this._manager.getBlockTypes();
+        if (blockTypes.length === 1) {
+            if (this._manager.getInlineEditingMode()) {
+                return undefined;
+            }
+        }
+        return pathBuilder?.({ view: 'create', index: index });
     }
     getPathForClipboard(index) {
         return this._catalogueRouteBuilderState.getValue()?.({ view: 'clipboard', index: index });

package/dist-cms/packages/block/block-single/context/block-single-manager.context.js

@@ -31,6 +31,7 @@ export class UmbBlockSingleManagerContext extends UmbBlockManagerContext {
     insert(layoutEntry, content, settings, originData) {
         this._layouts.appendOneAt(layoutEntry, originData.index ?? -1);
         this.insertBlockData(layoutEntry, content, settings, originData);
+        this.notifyBlockInserted(layoutEntry, originData);
         return true;
     }
 }

package/dist-cms/packages/block/block-single/property-editors/block-single-editor/property-editor-ui-block-single.element.js

@@ -8,7 +8,7 @@ import { UmbBlockSingleManagerContext } from '../../context/block-single-manager
 import { UmbBlockSingleEntriesContext } from '../../context/block-single-entries.context.js';
 import { UMB_BLOCK_SINGLE_PROPERTY_EDITOR_SCHEMA_ALIAS } from './constants.js';
 import { UmbLitElement, umbDestroyOnDisconnect } from '../../../../core/lit-element/index.js';
-import { html, customElement, property, state, repeat, css, nothing, } from '../../../../../external/lit/index.js';
+import { html, customElement, property, state, repeat, css, nothing, ifDefined, } from '../../../../../external/lit/index.js';
 import { UmbTextStyles } from '../../../../core/style/index.js';
 import { UmbSorterController } from '../../../../core/sorter/index.js';
 import '../../components/block-single-entry/index.js';
@@ -106,7 +106,7 @@ let UmbPropertyEditorUIBlockSingleElement = class UmbPropertyEditorUIBlockSingle
         });
         this.#validationContext = new UmbValidationContext(this);
         this.#lastValue = undefined;
-        this._createButtonLabel = this.localize.term('content_createEmpty');
+        this._createButtonLabel = this.localize.term('blockEditor_addBlock');
         this.#readonly = false;
         this._layouts = [];
         this.#managerContext = new UmbBlockSingleManagerContext(this);
@@ -291,21 +291,29 @@ let UmbPropertyEditorUIBlockSingleElement = class UmbPropertyEditorUIBlockSingle
         }
     }
     #renderCreateButton() {
-        let createPath;
-        if (this._blocks?.length === 1) {
-            const elementKey = this._blocks[0].contentElementTypeKey;
-            createPath =
-                this._catalogueRouteBuilder?.({ view: 'create', index: -1 }) + 'modal/umb-modal-workspace/create/' + elementKey;
-        }
-        else {
-            createPath = this._catalogueRouteBuilder?.({ view: 'create', index: -1 });
-        }
+        const createPath = this.#entriesContext.getPathForCreateBlock(-1);
         return html `
 			<uui-button
 				look="placeholder"
 				label=${this._createButtonLabel}
-				href=${createPath ?? ''}
-				?disabled=${this.readonly}></uui-button>
+				href=${ifDefined(createPath)}
+				?disabled=${this.readonly}
+				@click=${async () => {
+            // If no path, then we can conclude there is not modal flow for the user to follow, instead we will just insert the Block: [NL]
+            if (createPath === undefined) {
+                if (!this._blocks || this._blocks.length === 0) {
+                    throw new Error('No block types are configured for this Block List property editor');
+                }
+                const originData = { index: -1 };
+                const created = await this.#entriesContext.create(this._blocks[0].contentElementTypeKey, {}, originData);
+                if (created) {
+                    this.#entriesContext.insert(created.layout, created.content, created.settings, originData);
+                }
+                else {
+                    throw new Error('Failed to create block');
+                }
+            }
+        }}></uui-button>
 		`;
     }
     #renderPasteButton() {
@@ -322,18 +330,8 @@ let UmbPropertyEditorUIBlockSingleElement = class UmbPropertyEditorUIBlockSingle
     static { this.styles = [
         UmbTextStyles,
         css `
-			:host {
-				display: grid;
-				gap: 1px;
-			}
-			> div {
-				display: flex;
-				flex-direction: column;
-				align-items: stretch;
-			}
-
 			uui-button-group {
-				padding-top: 1px;
+				margin-top: 1px;
 				display: grid;
 				grid-template-columns: 1fr auto;
 			}

package/dist-cms/packages/block/vite.config.js

@@ -12,6 +12,7 @@ export default defineConfig({
             'block-custom-view/index': 'block-custom-view/index.ts',
             'block-grid/index': 'block-grid/index.ts',
             'block-list/index': 'block-list/index.ts',
+            'block-single/index': 'block-single/index.ts',
             'block-rte/index': 'block-rte/index.ts',
             'block-type/index': 'block-type/index.ts',
             manifests: 'manifests.ts',

package/dist-cms/packages/content/content/audit-log/audit-log-action/audit-log-action-default.kind.d.ts

@@ -0,0 +1,3 @@
+import type { UmbExtensionManifestKind } from '../../../../core/extension-registry/index.js';
+export declare const UMB_AUDIT_LOG_ACTION_DEFAULT_KIND_MANIFEST: UmbExtensionManifestKind;
+export declare const manifest: UmbExtensionManifestKind;

package/dist-cms/packages/content/content/audit-log/audit-log-action/audit-log-action-default.kind.js

@@ -0,0 +1,18 @@
+export const UMB_AUDIT_LOG_ACTION_DEFAULT_KIND_MANIFEST = {
+    type: 'kind',
+    alias: 'Umb.Kind.AuditLogAction.Default',
+    matchKind: 'default',
+    matchType: 'auditLogAction',
+    manifest: {
+        type: 'auditLogAction',
+        kind: 'default',
+        weight: 1000,
+        element: () => import('./audit-log-action.element.js'),
+        forEntityTypes: [],
+        meta: {
+            icon: '',
+            label: 'Default Audit Log Action',
+        },
+    },
+};
+export const manifest = UMB_AUDIT_LOG_ACTION_DEFAULT_KIND_MANIFEST;

package/dist-cms/packages/content/content/audit-log/audit-log-action/audit-log-action.element.d.ts

@@ -0,0 +1,19 @@
+import type { ManifestAuditLogAction } from './audit-log-action.extension.js';
+import type { MetaAuditLogActionDefaultKind } from './types.js';
+import { nothing } from '../../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import type { UmbEntityAction, UmbEntityActionElement } from '../../../../core/entity-action/index.js';
+export default class UmbAuditLogActionElement<MetaType extends MetaAuditLogActionDefaultKind = MetaAuditLogActionDefaultKind, ApiType extends UmbEntityAction<MetaType> = UmbEntityAction<MetaType>> extends UmbLitElement implements UmbEntityActionElement {
+    #private;
+    entityType?: string | null;
+    unique?: string | null;
+    manifest?: ManifestAuditLogAction<MetaType>;
+    set api(api: ApiType | undefined);
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+}
+export { UmbAuditLogActionElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-audit-log-action': UmbAuditLogActionElement;
+    }
+}

package/dist-cms/packages/content/content/audit-log/audit-log-action/audit-log-action.element.js

@@ -0,0 +1,54 @@
+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 { customElement, html, nothing, property, when } from '../../../../../external/lit/index.js';
+import { UmbActionExecutedEvent } from '../../../../core/event/index.js';
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+let UmbAuditLogActionElement = class UmbAuditLogActionElement extends UmbLitElement {
+    #api;
+    set api(api) {
+        this.#api = api;
+    }
+    async #onClick(event) {
+        event.stopPropagation();
+        try {
+            await this.#api?.execute();
+            this.dispatchEvent(new UmbActionExecutedEvent());
+        }
+        catch (error) {
+            console.error('Error executing action:', error);
+        }
+    }
+    render() {
+        if (!this.manifest)
+            return nothing;
+        const label = this.manifest.meta.label ? this.localize.string(this.manifest.meta.label) : this.manifest.name;
+        return html `
+			<uui-button
+				compact
+				data-mark=${'audit-log-action:' + this.manifest?.alias}
+				label=${label}
+				@click=${this.#onClick}>
+				${when(this.manifest.meta.icon, (icon) => html `<umb-icon name=${icon}></umb-icon>`)}
+				<span>${label}</span>
+			</uui-button>
+		`;
+    }
+};
+__decorate([
+    property({ type: String })
+], UmbAuditLogActionElement.prototype, "entityType", void 0);
+__decorate([
+    property({ type: String })
+], UmbAuditLogActionElement.prototype, "unique", void 0);
+__decorate([
+    property({ attribute: false })
+], UmbAuditLogActionElement.prototype, "manifest", void 0);
+UmbAuditLogActionElement = __decorate([
+    customElement('umb-audit-log-action')
+], UmbAuditLogActionElement);
+export default UmbAuditLogActionElement;
+export { UmbAuditLogActionElement as element };

package/dist-cms/packages/content/content/audit-log/audit-log-action/audit-log-action.extension.d.ts

@@ -0,0 +1,14 @@
+import type { UmbEntityActionElement, UmbEntityAction } from '../../../../core/entity-action/index.js';
+import type { ManifestElementAndApi, ManifestWithDynamicConditions } from '../../../../../libs/extension-api/index.js';
+export interface ManifestAuditLogAction<MetaType extends MetaAuditLogAction = MetaAuditLogAction> extends ManifestElementAndApi<UmbEntityActionElement, UmbEntityAction<MetaType>>, ManifestWithDynamicConditions<UmbExtensionConditionConfig> {
+    type: 'auditLogAction';
+    forEntityTypes: Array<string>;
+    meta: MetaType;
+}
+export interface MetaAuditLogAction {
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbAuditLogAction: ManifestAuditLogAction;
+    }
+}

package/dist-cms/packages/content/content/audit-log/audit-log-action/content-rollback.audit-log-action.kind.d.ts

@@ -0,0 +1,3 @@
+import type { UmbExtensionManifestKind } from '../../../../core/extension-registry/index.js';
+export declare const UMB_AUDIT_LOG_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST: UmbExtensionManifestKind;
+export declare const manifest: UmbExtensionManifestKind;

package/dist-cms/packages/content/content/audit-log/audit-log-action/content-rollback.audit-log-action.kind.js

@@ -0,0 +1,22 @@
+export const UMB_AUDIT_LOG_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST = {
+    type: 'kind',
+    alias: 'Umb.Kind.AuditLogAction.ContentRollback',
+    matchKind: 'contentRollback',
+    matchType: 'auditLogAction',
+    manifest: {
+        type: 'auditLogAction',
+        kind: 'contentRollback',
+        element: () => import('./audit-log-action.element.js'),
+        api: () => import('../../rollback/entity-action/content-rollback.action.js'),
+        weight: 450,
+        forEntityTypes: [],
+        meta: {
+            icon: 'icon-history',
+            label: '#actions_rollback',
+            additionalOptions: true,
+            rollbackRepositoryAlias: '',
+            detailRepositoryAlias: '',
+        },
+    },
+};
+export const manifest = UMB_AUDIT_LOG_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST;

package/dist-cms/packages/content/content/audit-log/audit-log-action/manifests.d.ts

@@ -0,0 +1,2 @@
+import type { UmbExtensionManifestKind } from '../../../../core/extension-registry/index.js';
+export declare const manifests: Array<UmbExtensionManifestKind>;

package/dist-cms/packages/content/content/audit-log/audit-log-action/manifests.js

@@ -0,0 +1,3 @@
+import { manifest as defaultKindManifest } from './audit-log-action-default.kind.js';
+import { manifest as contentRollbackKindManifest } from './content-rollback.audit-log-action.kind.js';
+export const manifests = [defaultKindManifest, contentRollbackKindManifest];

package/dist-cms/packages/content/content/audit-log/audit-log-action/types.d.ts

@@ -0,0 +1,17 @@
+import type { ManifestAuditLogAction, MetaAuditLogAction } from './audit-log-action.extension.js';
+export type * from './audit-log-action.extension.js';
+export type { UmbAuditLogTagData, UmbAuditLogTagLocalizeKeys, UmbAuditLogTagStyleMap, } from '../../../../core/audit-log/index.js';
+export interface MetaAuditLogActionDefaultKind extends MetaAuditLogAction {
+    icon: string;
+    label: string;
+    additionalOptions?: boolean;
+}
+export interface ManifestAuditLogActionDefaultKind extends ManifestAuditLogAction<MetaAuditLogActionDefaultKind> {
+    type: 'auditLogAction';
+    kind: 'default';
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbAuditLogActionDefaultKind: ManifestAuditLogActionDefaultKind;
+    }
+}

package/dist-cms/packages/content/content/audit-log/audit-log-action/types.js

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

package/dist-cms/packages/content/content/audit-log/index.d.ts

@@ -0,0 +1,4 @@
+export { UMB_AUDIT_LOG_ACTION_DEFAULT_KIND_MANIFEST } from './audit-log-action/audit-log-action-default.kind.js';
+export { UMB_AUDIT_LOG_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST } from './audit-log-action/content-rollback.audit-log-action.kind.js';
+export type * from './audit-log-action/types.js';
+export type * from './info-app/types.js';

package/dist-cms/packages/content/content/audit-log/index.js

@@ -0,0 +1,2 @@
+export { UMB_AUDIT_LOG_ACTION_DEFAULT_KIND_MANIFEST } from './audit-log-action/audit-log-action-default.kind.js';
+export { UMB_AUDIT_LOG_ACTION_CONTENT_ROLLBACK_KIND_MANIFEST } from './audit-log-action/content-rollback.audit-log-action.kind.js';

package/dist-cms/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.element.d.ts

@@ -0,0 +1,21 @@
+import type { ManifestWorkspaceInfoAppAuditLogKind } from './types.js';
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+export declare class UmbContentAuditLogWorkspaceInfoAppElement extends UmbLitElement {
+    #private;
+    private _manifest?;
+    get manifest(): ManifestWorkspaceInfoAppAuditLogKind | undefined;
+    set manifest(value: ManifestWorkspaceInfoAppAuditLogKind | undefined);
+    private _currentPageNumber;
+    private _entityType?;
+    private _items;
+    private _totalPages;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export { UmbContentAuditLogWorkspaceInfoAppElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-content-audit-log-workspace-info-app': UmbContentAuditLogWorkspaceInfoAppElement;
+    }
+}

package/dist-cms/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.element.js

@@ -0,0 +1,220 @@
+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 { css, customElement, html, nothing, property, repeat, state, when } from '../../../../../external/lit/index.js';
+import { createExtensionApiByAlias } from '../../../../core/extension-registry/index.js';
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import { UmbPaginationManager } from '../../../../core/utils/index.js';
+import { UmbRequestReloadStructureForEntityEvent } from '../../../../core/entity-action/index.js';
+import { UmbTextStyles } from '../../../../core/style/index.js';
+import { UmbUserItemRepository } from '../../../../user/user/index.js';
+import { UMB_ACTION_EVENT_CONTEXT } from '../../../../core/action/index.js';
+import { UMB_ENTITY_WORKSPACE_CONTEXT } from '../../../../core/workspace/index.js';
+const TimeOptions = {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+};
+let UmbContentAuditLogWorkspaceInfoAppElement = class UmbContentAuditLogWorkspaceInfoAppElement extends UmbLitElement {
+    get manifest() {
+        return this._manifest;
+    }
+    set manifest(value) {
+        this._manifest = value;
+        this.#init();
+    }
+    #auditLogRepository;
+    #pagination;
+    #userItemRepository;
+    #userMap;
+    #workspaceContext;
+    constructor() {
+        super();
+        this._currentPageNumber = 1;
+        this._items = [];
+        this._totalPages = 1;
+        this.#pagination = new UmbPaginationManager();
+        this.#userItemRepository = new UmbUserItemRepository(this);
+        this.#userMap = new Map();
+        this.#pagination.setPageSize(10);
+        this.observe(this.#pagination.currentPage, (number) => (this._currentPageNumber = number));
+        this.observe(this.#pagination.totalPages, (number) => (this._totalPages = number));
+        this.consumeContext(UMB_ACTION_EVENT_CONTEXT, (context) => {
+            context?.addEventListener(UmbRequestReloadStructureForEntityEvent.TYPE, () => {
+                this.#requestAuditLogs();
+            });
+        });
+        this.consumeContext(UMB_ENTITY_WORKSPACE_CONTEXT, (instance) => {
+            this.#workspaceContext = instance;
+            this.#requestAuditLogs();
+        });
+    }
+    async #init() {
+        if (!this._manifest)
+            return;
+        const auditLogRepositoryAlias = this._manifest.meta.auditLogRepositoryAlias;
+        if (!auditLogRepositoryAlias) {
+            throw new Error('Audit log repository alias is required');
+        }
+        this.#auditLogRepository = await createExtensionApiByAlias(this, auditLogRepositoryAlias);
+        this.#requestAuditLogs();
+    }
+    #onPageChange(event) {
+        this.#pagination.setCurrentPageNumber(event.target?.current);
+        this.#requestAuditLogs();
+    }
+    async #requestAuditLogs() {
+        if (!this.#workspaceContext)
+            return;
+        if (!this.#auditLogRepository)
+            return;
+        const unique = this.#workspaceContext.getUnique();
+        if (!unique) {
+            throw new Error('Workspace entity unique is required');
+        }
+        this._entityType = this.#workspaceContext.getEntityType();
+        const { data } = await this.#auditLogRepository.requestAuditLog({
+            unique,
+            skip: this.#pagination.getSkip(),
+            take: this.#pagination.getPageSize(),
+        });
+        if (data) {
+            this._items = data.items;
+            this.#pagination.setTotalItems(data.total);
+            this.#requestAndCacheUserItems();
+        }
+    }
+    async #requestAndCacheUserItems() {
+        const allUsers = this._items?.map((item) => item.user.unique).filter(Boolean);
+        const uniqueUsers = [...new Set(allUsers)];
+        const uncachedUsers = uniqueUsers.filter((unique) => !this.#userMap.has(unique));
+        // If there are no uncached user items, we don't need to make a request
+        if (uncachedUsers.length === 0)
+            return;
+        const { data: items } = await this.#userItemRepository.requestItems(uncachedUsers);
+        if (items) {
+            items.forEach((item) => {
+                // cache the user item
+                this.#userMap.set(item.unique, item);
+                this.requestUpdate('_items');
+            });
+        }
+    }
+    render() {
+        return html `
+			<umb-workspace-info-app-layout headline="#general_history">
+				${when(this._entityType, (entityType) => html `
+						<umb-extension-with-api-slot
+							slot="header-actions"
+							type="auditLogAction"
+							.apiArgs=${(manifest) => [manifest]}
+							.filter=${(manifest) => manifest.forEntityTypes.includes(entityType)}>
+						</umb-extension-with-api-slot>
+					`)}
+				<div id="content">
+					${when(this._items, () => this.#renderHistory(), () => html `<div id="loader"><uui-loader></uui-loader></div>`)}
+					${this.#renderPagination()}
+				</div>
+			</umb-workspace-info-app-layout>
+		`;
+    }
+    #renderHistory() {
+        if (!this._items?.length)
+            return html `${this.localize.term('content_noItemsToShow')}`;
+        return html `
+			<umb-history-list>
+				${repeat(this._items, (item) => item.timestamp, (item) => this.#renderHistoryItem(item))}
+			</umb-history-list>
+		`;
+    }
+    #renderHistoryItem(item) {
+        const tagData = this.#auditLogRepository?.getTagStyleAndText?.(item.logType);
+        const user = this.#userMap.get(item.user.unique);
+        return html `
+			<umb-history-item .name=${user?.name ?? 'Unknown'} .detail=${this.localize.date(item.timestamp, TimeOptions)}>
+				<umb-user-avatar slot="avatar" .name=${user?.name} .kind=${user?.kind} .imgUrls=${user?.avatarUrls ?? []}>
+				</umb-user-avatar>
+				<div class="log-type">
+					<uui-tag look=${tagData?.style.look ?? 'placeholder'} color=${tagData?.style.color ?? 'default'}>
+						${this.localize.term(tagData?.text.label ?? item.logType, item.parameters)}
+					</uui-tag>
+					<span>${this.localize.term(tagData?.text.desc ?? '', item.parameters)}</span>
+				</div>
+			</umb-history-item>
+		`;
+    }
+    #renderPagination() {
+        if (this._totalPages <= 1)
+            return nothing;
+        return html `
+			<uui-pagination
+				.current=${this._currentPageNumber}
+				.total=${this._totalPages}
+				firstlabel=${this.localize.term('general_first')}
+				previouslabel=${this.localize.term('general_previous')}
+				nextlabel=${this.localize.term('general_next')}
+				lastlabel=${this.localize.term('general_last')}
+				@change=${this.#onPageChange}></uui-pagination>
+		`;
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			#content {
+				display: block;
+				padding: var(--uui-size-space-4) var(--uui-size-space-5);
+			}
+
+			#loader {
+				display: flex;
+				justify-content: center;
+			}
+
+			.log-type {
+				display: grid;
+				grid-template-columns: var(--uui-size-40) auto;
+				gap: var(--uui-size-layout-1);
+			}
+
+			.log-type uui-tag {
+				justify-self: center;
+				height: fit-content;
+				margin-top: auto;
+				margin-bottom: auto;
+			}
+
+			uui-pagination {
+				flex: 1;
+				display: flex;
+				justify-content: center;
+				margin-top: var(--uui-size-layout-1);
+			}
+		`,
+    ]; }
+};
+__decorate([
+    property({ type: Object })
+], UmbContentAuditLogWorkspaceInfoAppElement.prototype, "_manifest", void 0);
+__decorate([
+    state()
+], UmbContentAuditLogWorkspaceInfoAppElement.prototype, "_currentPageNumber", void 0);
+__decorate([
+    state()
+], UmbContentAuditLogWorkspaceInfoAppElement.prototype, "_entityType", void 0);
+__decorate([
+    state()
+], UmbContentAuditLogWorkspaceInfoAppElement.prototype, "_items", void 0);
+__decorate([
+    state()
+], UmbContentAuditLogWorkspaceInfoAppElement.prototype, "_totalPages", void 0);
+UmbContentAuditLogWorkspaceInfoAppElement = __decorate([
+    customElement('umb-content-audit-log-workspace-info-app')
+], UmbContentAuditLogWorkspaceInfoAppElement);
+export { UmbContentAuditLogWorkspaceInfoAppElement };
+export { UmbContentAuditLogWorkspaceInfoAppElement as element };

package/dist-cms/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.kind.d.ts

@@ -0,0 +1,2 @@
+import type { UmbExtensionManifestKind } from '../../../../core/extension-registry/index.js';
+export declare const manifest: UmbExtensionManifestKind;

package/dist-cms/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.kind.js

@@ -0,0 +1,12 @@
+export const manifest = {
+    type: 'kind',
+    alias: 'Umb.Kind.WorkspaceInfoApp.AuditLog',
+    matchKind: 'auditLog',
+    matchType: 'workspaceInfoApp',
+    manifest: {
+        type: 'workspaceInfoApp',
+        kind: 'auditLog',
+        element: () => import('./content-audit-log-workspace-info-app.element.js'),
+        weight: 80,
+    },
+};

package/dist-cms/packages/content/content/audit-log/info-app/manifests.d.ts

@@ -0,0 +1,2 @@
+import type { UmbExtensionManifestKind } from '../../../../core/extension-registry/index.js';
+export declare const manifests: Array<UmbExtensionManifest | UmbExtensionManifestKind>;

package/dist-cms/packages/content/content/audit-log/info-app/manifests.js

@@ -0,0 +1,2 @@
+import { manifest as auditLogKindManifest } from './content-audit-log-workspace-info-app.kind.js';
+export const manifests = [auditLogKindManifest];