@umbraco-cms/backoffice 17.6.0 → 17.6.2

package/dist-cms/external/uui/uui-popover.element.js

@@ -0,0 +1,457 @@
+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 { defineElement } from '@umbraco-ui/uui';
+import { property, query, css, html, LitElement } from '../lit/index.js';
+import { UUIPopoverEvent } from './UUIPopoverEvent.js';
+// ------------------- Math extensions ---------------------
+function mathClamp(value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    else if (value > max) {
+        return max;
+    }
+    return value;
+}
+/**
+ * @deprecated This component has been deprecated and will be removed in future releases. It is being replaced by popover-container.
+ * @element uui-popover
+ * @description Open a modal aligned with the opening element. This does not jet work within two layers of scroll containers.
+ * @fires close - When popover is closed by user interaction.
+ * @slot trigger - The element that triggers the popover.
+ * @slot popover - The content of the popover.
+ * @cssprop --uui-popover-z-index - overwrite the z-index of the popover container.
+ */
+let UUIPopoverElement = class UUIPopoverElement extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.scrollEventHandler = this._updatePlacement.bind(this);
+        this._open = false;
+        this._placement = 'bottom-start';
+        this._currentPlacement = null;
+        this._scrollParents = [];
+        /**
+         * Set the distance between popover-modal and trigger.
+         * @type {number}
+         * @attr margin
+         * @default 0
+         */
+        this.margin = 0;
+        this._onTriggerSlotChanged = (event) => {
+            this._trigger = event.target.assignedElements({
+                flatten: true,
+            })[0];
+        };
+        this._intersectionCallback = (entries) => {
+            entries.forEach((entry) => {
+                if (entry.isIntersecting === false) {
+                    this._startScrollListener();
+                    this._updatePlacement();
+                }
+            });
+        };
+        this._onKeyUp = (event) => {
+            if (event.key === 'Escape') {
+                this._triggerPopoverClose();
+                return;
+            }
+        };
+        this._onDocumentClick = (event) => {
+            if (!event.composedPath().includes(this)) {
+                this._triggerPopoverClose();
+            }
+        };
+    }
+    /**
+     * Define the placement of the popover-modal.
+     * @attr placement
+     * @default 'bottom-start'
+     */
+    get placement() {
+        return this._placement;
+    }
+    set placement(newValue) {
+        const oldValue = this._placement;
+        this._placement = newValue || 'bottom-start';
+        this._currentPlacement = null;
+        this._updatePlacement();
+        this.requestUpdate('placement', oldValue);
+    }
+    /**
+     * Opens the popover-modal.
+     * @type {boolean}
+     * @attr open
+     * @default false
+     */
+    get open() {
+        return this._open;
+    }
+    set open(newValue) {
+        const oldValue = this._open;
+        this._open = newValue;
+        if (newValue) {
+            this._openPopover();
+        }
+        else {
+            this._closePopover();
+        }
+        this.requestUpdate('open', oldValue);
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this._getScrollParents();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        document.removeEventListener('mousedown', this._onDocumentClick);
+        document.removeEventListener('keyup', this._onKeyUp);
+        document.removeEventListener('scroll', this.scrollEventHandler);
+        if (this.intersectionObserver) {
+            this.intersectionObserver.disconnect();
+            delete this.intersectionObserver;
+        }
+        this._scrollParents = [];
+    }
+    _openPopover() {
+        if (this.containerElement) {
+            this.containerElement.style.opacity = '0'; // Hide while measuring popover size.
+            document.addEventListener('mousedown', this._onDocumentClick);
+            document.addEventListener('keyup', this._onKeyUp);
+            this._currentPlacement = null;
+            requestAnimationFrame(() => {
+                this._updatePlacement();
+                this._createIntersectionObserver();
+                this.containerElement.style.opacity = '1';
+            });
+        }
+    }
+    _closePopover() {
+        if (this.intersectionObserver) {
+            this.intersectionObserver.disconnect();
+            delete this.intersectionObserver;
+        }
+        document.removeEventListener('mousedown', this._onDocumentClick);
+        document.removeEventListener('keyup', this._onKeyUp);
+        this._currentPlacement = null;
+    }
+    // Use this when changing the open state from within this component.
+    _triggerPopoverClose() {
+        const event = new UUIPopoverEvent(UUIPopoverEvent.CLOSE, {
+            cancelable: true,
+        });
+        this.dispatchEvent(event);
+        if (event.defaultPrevented)
+            return;
+        this.open = false;
+    }
+    _getScrollParents() {
+        // Clear previous scroll parents to avoid duplicates
+        this._scrollParents = [];
+        const hostElement = this.shadowRoot.host;
+        let style = getComputedStyle(hostElement);
+        if (style.position === 'fixed') {
+            return;
+        }
+        const includeHidden = false;
+        const excludeStaticParent = style.position === 'absolute';
+        const overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/;
+        let el = hostElement;
+        while (el) {
+            style = getComputedStyle(el);
+            if (excludeStaticParent && style.position === 'static') {
+                el = this._getAncestorElement(el);
+                continue;
+            }
+            if (overflowRegex.test(style.overflow + style.overflowY + style.overflowX)) {
+                this._scrollParents.push(el);
+            }
+            if (style.position === 'fixed') {
+                return;
+            }
+            el = this._getAncestorElement(el);
+        }
+        this._scrollParents.push(document.body);
+    }
+    _getAncestorElement(el) {
+        if (el?.parentElement) {
+            return el.parentElement;
+        }
+        else {
+            // If we had no parentElement, then check for shadow roots:
+            return el?.getRootNode()?.host;
+        }
+    }
+    _createIntersectionObserver() {
+        if (this.intersectionObserver) {
+            // break out, as we already have it
+            return;
+        }
+        const options = {
+            root: null,
+            rootMargin: '0px',
+            threshold: 1,
+        };
+        this.intersectionObserver = new IntersectionObserver(this._intersectionCallback, options);
+        this.intersectionObserver.observe(this.containerElement);
+    }
+    _startScrollListener() {
+        this._scrollParents.forEach((el) => {
+            el.addEventListener('scroll', this.scrollEventHandler);
+        });
+        document.addEventListener('scroll', this.scrollEventHandler);
+    }
+    _stopScrollListener() {
+        this._scrollParents.forEach((el) => {
+            el.removeEventListener('scroll', this.scrollEventHandler);
+        });
+        document.removeEventListener('scroll', this.scrollEventHandler);
+    }
+    _updatePlacement() {
+        if (!this.shadowRoot) {
+            return;
+        }
+        const containerElement = this.containerElement;
+        if (!containerElement) {
+            return;
+        }
+        const popoverRect = this.containerElement?.getBoundingClientRect();
+        const triggerRect = this._trigger?.getBoundingClientRect();
+        if (triggerRect != null && popoverRect != null) {
+            const scrollParentRects = this._scrollParents.map((el) => el.getBoundingClientRect());
+            this._currentPlacement = this._currentPlacement || this._placement;
+            if (this._placement !== 'auto') {
+                this._currentPlacement = this._managePlacementFlip(this._currentPlacement, popoverRect, scrollParentRects);
+            }
+            let isTopPlacement = this._currentPlacement.indexOf('top') !== -1;
+            let isBottomPlacement = this._currentPlacement.indexOf('bottom') !== -1;
+            let isLeftPlacement = this._currentPlacement.indexOf('left') !== -1;
+            let isRightPlacement = this._currentPlacement.indexOf('right') !== -1;
+            const isStart = this._currentPlacement.indexOf('-start') !== -1;
+            const isEnd = this._currentPlacement.indexOf('-end') !== -1;
+            // -------- | INITIATE MATH | --------
+            let originX = 0.5;
+            let originY = 0.5;
+            let alignX = 0.5;
+            let alignY = 0.5;
+            let marginX = 0;
+            let marginY = 0;
+            if (this.placement === 'auto') {
+                const firstScrollParent = this._scrollParents[0];
+                const scrollParentWidth = firstScrollParent.clientWidth;
+                const scrollParentHeight = firstScrollParent.clientHeight;
+                const spaceLeft = triggerRect.x - popoverRect.width;
+                const spaceRight = scrollParentWidth - (triggerRect.x + triggerRect.width) - popoverRect.width;
+                const spaceTop = triggerRect.y - popoverRect.height;
+                const spaceBottom = scrollParentHeight - (triggerRect.y + triggerRect.height) - popoverRect.height;
+                let dirX = 0.5;
+                let dirY = 0.5;
+                const hMaxSpace = Math.max(spaceLeft, spaceRight);
+                let vMaxSpace = Math.max(spaceTop, spaceBottom);
+                // if we have more space below than above, and there is enough room, then we will pick below.
+                if (spaceBottom > spaceTop && spaceBottom > this.margin) {
+                    vMaxSpace += 9999;
+                }
+                if (hMaxSpace > vMaxSpace) {
+                    if (spaceLeft > spaceRight) {
+                        dirX = 0;
+                        isLeftPlacement = true;
+                    }
+                    else {
+                        dirX = 1;
+                        isRightPlacement = true;
+                    }
+                    marginX = this.margin;
+                }
+                else {
+                    if (spaceTop > spaceBottom) {
+                        dirY = 0;
+                        isTopPlacement = true;
+                    }
+                    else {
+                        dirY = 1;
+                        isBottomPlacement = true;
+                    }
+                    marginY = this.margin;
+                }
+                originX = dirX;
+                originY = dirY;
+                alignX = 1 - dirX;
+                alignY = 1 - dirY;
+            }
+            else {
+                // -------- TOP / BOT --------
+                if (isTopPlacement) {
+                    alignY = 1;
+                    originY = 0;
+                }
+                if (isBottomPlacement) {
+                    alignY = 0;
+                    originY = 1;
+                }
+                if (isTopPlacement || isBottomPlacement) {
+                    marginY = this.margin;
+                    if (isStart) {
+                        alignX = 0;
+                        originX = 0;
+                    }
+                    if (isEnd) {
+                        alignX = 1;
+                        originX = 1;
+                    }
+                }
+                // -------- LEFT / RIGHT --------
+                if (isLeftPlacement) {
+                    alignX = 1;
+                    originX = 0;
+                }
+                if (isRightPlacement) {
+                    alignX = 0;
+                    originX = 1;
+                }
+                if (isLeftPlacement || isRightPlacement) {
+                    marginX = this.margin;
+                    if (isStart) {
+                        alignY = 0;
+                        originY = 0;
+                    }
+                    if (isEnd) {
+                        alignY = 1;
+                        originY = 1;
+                    }
+                }
+            }
+            const calcX = -popoverRect.width * alignX + triggerRect.width * originX - marginX * (alignX * 2 - 1);
+            const calcY = -popoverRect.height * alignY + triggerRect.height * originY - marginY * (alignY * 2 - 1);
+            let posX = calcX;
+            let posY = calcY;
+            // Moves the popover to keep it fully visible on the screen as long as its still in contact with the trigger.
+            // Only do this clamp if popover is on the top or bottom of the parent.
+            if (isTopPlacement || isBottomPlacement) {
+                this._scrollParents.forEach((el, index) => {
+                    const rectX = el === document.body ? 0 : scrollParentRects[index].x;
+                    const leftClamp = -triggerRect.x + rectX;
+                    const rightClamp = el.clientWidth -
+                        triggerRect.x -
+                        triggerRect.width +
+                        calcX +
+                        rectX -
+                        (popoverRect.width - triggerRect.width) * (1 - originX);
+                    posX = mathClamp(posX, leftClamp, rightClamp);
+                });
+                // keep within contact of the trigger, must be last:
+                posX = mathClamp(posX, -popoverRect.width, triggerRect.width);
+            }
+            else if (isLeftPlacement || isRightPlacement) {
+                // Only do this clamp if popover is on the sides of the parent.
+                this._scrollParents.forEach((el, index) => {
+                    const rectY = el === document.body ? 0 : scrollParentRects[index].y;
+                    const topClamp = -triggerRect.y + rectY;
+                    const bottomClamp = el.clientHeight -
+                        triggerRect.y -
+                        triggerRect.height +
+                        calcY +
+                        rectY -
+                        (popoverRect.height - triggerRect.height) * (1 - originY);
+                    posY = mathClamp(posY, topClamp, bottomClamp);
+                });
+                // keep within contact of the trigger, must be last:
+                posY = mathClamp(posY, -popoverRect.height, triggerRect.height);
+            }
+            if (this._positionX !== posX || this._positionY !== posY) {
+                this._positionX = posX;
+                this._positionY = posY;
+                if (calcX === posX && calcY === posY) {
+                    // Not offset anymore, so we can stop listening for scroll events:
+                    this._stopScrollListener();
+                }
+                containerElement.style.left = `${this._positionX}px`;
+                containerElement.style.top = `${this._positionY}px`;
+            }
+        }
+    }
+    _managePlacementFlip(currentPlacement, popoverRect, scrollParentRects) {
+        const buffer = 2; // add this to the calculation make sure that the position checks are not off by e.g: 0.1 pixel.
+        const placementSplit = currentPlacement.split('-');
+        const currentSide = placementSplit[0];
+        const placementAlign = placementSplit[1] || null;
+        let sideFlip;
+        this._scrollParents.some((el, index) => {
+            const rectX = el === document.body ? 0 : scrollParentRects[index].x;
+            const rectY = el === document.body ? 0 : scrollParentRects[index].y;
+            if (currentSide === 'top' && popoverRect.y - buffer <= rectY) {
+                sideFlip = 'bottom';
+                return true;
+            }
+            if (currentSide === 'bottom' && popoverRect.y + popoverRect.height + buffer >= el.clientHeight + rectY) {
+                sideFlip = 'top';
+                return true;
+            }
+            if (currentSide === 'left' && popoverRect.x - buffer <= rectX) {
+                sideFlip = 'right';
+                return true;
+            }
+            if (currentSide === 'right' && popoverRect.x + popoverRect.width + buffer >= el.clientWidth + rectX) {
+                sideFlip = 'left';
+                return true;
+            }
+            return false;
+        });
+        if (sideFlip) {
+            this._startScrollListener();
+            return (sideFlip + (placementAlign ? `-${placementAlign}` : ''));
+        }
+        return currentPlacement;
+    }
+    render() {
+        return html `
+			<slot id="trigger" name="trigger" @slotchange=${this._onTriggerSlotChanged}></slot>
+			<div id="container">${this._open ? html `<slot name="popover"></slot>` : ''}</div>
+		`;
+    }
+    static { this.styles = [
+        css `
+			:host {
+				position: relative;
+				display: inline-block;
+				width: 100%;
+			}
+			#container {
+				position: absolute;
+				width: 100%;
+				z-index: var(--uui-popover-z-index, 1);
+			}
+			slot[name='popover'] {
+				display: block;
+			}
+			#trigger {
+				position: relative;
+				width: 100%;
+			}
+
+			slot[name='trigger']::slotted(uui-button) {
+				--uui-button-border-radius: var(--uui-popover-toggle-slot-button-border-radius);
+				--uui-button-merge-border-left: var(--uui-popover-toggle-slot-button-merge-border-left);
+			}
+		`,
+    ]; }
+};
+__decorate([
+    query('#container')
+], UUIPopoverElement.prototype, "containerElement", void 0);
+__decorate([
+    property({ type: Number })
+], UUIPopoverElement.prototype, "margin", void 0);
+__decorate([
+    property({ type: String, reflect: true })
+], UUIPopoverElement.prototype, "placement", null);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], UUIPopoverElement.prototype, "open", null);
+UUIPopoverElement = __decorate([
+    defineElement('uui-popover')
+], UUIPopoverElement);
+export { UUIPopoverElement };

package/dist-cms/packages/block/block/action/block-action-list.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbBlockActionListElement extends UmbLitElement {
     private _showActions?;
     private _actions;
     constructor();
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist-cms/packages/block/block/action/default/block-action.element.d.ts

@@ -15,7 +15,7 @@ export declare class UmbBlockActionDefaultElement<MetaType extends MetaBlockActi
     set api(api: ApiType | undefined);
     private _href?;
     private _invalid;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static styles: import("lit").CSSResult[];
 }
 export default UmbBlockActionDefaultElement;

package/dist-cms/packages/block/block/components/block-overlay-expose-button/block-overlay-expose-button.element.d.ts

@@ -6,7 +6,7 @@ import { UmbLitElement } from '../../../../core/lit-element/index.js';
  */
 export declare class UmbBlockOverlayExposeButtonElement extends UmbLitElement {
     contentTypeName?: string;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static styles: import("lit").CSSResult[];
 }
 export default UmbBlockOverlayExposeButtonElement;

package/dist-cms/packages/block/block/workspace/views/edit/block-workspace-view-edit-property.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbBlockWorkspaceViewEditPropertyElement extends UmbLitElem
     private _dataTypeDetail?;
     ownerContext?: UmbBlockElementManager;
     willUpdate(changedProperties: Map<string, any>): void;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export default UmbBlockWorkspaceViewEditPropertyElement;
 declare global {

package/dist-cms/packages/block/block-grid/components/block-grid-areas-container/block-grid-areas-container.element.d.ts

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

package/dist-cms/packages/block/block-grid/property-editors/block-grid-area-type-permission/block-grid-area-type-permission.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbPropertyEditorUIBlockGridAreaTypePermissionElement exten
     private _blockTypesWithElementName;
     private _blockGroups;
     constructor();
-    render(): typeof nothing | import("lit-html").TemplateResult<1> | "There must be one Block Type created before permissions can be configured.";
+    render(): import("lit-html").TemplateResult<1> | typeof nothing | "There must be one Block Type created before permissions can be configured.";
     static styles: import("lit").CSSResult[];
 }
 export default UmbPropertyEditorUIBlockGridAreaTypePermissionElement;

package/dist-cms/packages/block/block-grid/property-editors/block-grid-editor/property-editor-ui-block-grid.element.d.ts

@@ -27,7 +27,7 @@ export declare class UmbPropertyEditorUIBlockGridElement extends UmbPropertyEdit
     get value(): UmbBlockGridValueModel | undefined;
     constructor();
     protected firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static styles: import("lit").CSSResult[];
 }
 export default UmbPropertyEditorUIBlockGridElement;

package/dist-cms/packages/block/block-grid/property-editors/block-grid-editor/value-summary/value-summary.element.d.ts

@@ -2,7 +2,7 @@ import { nothing } from '../../../../../../external/lit/index.js';
 import { UmbValueSummaryElementBase } from '../../../../../core/value-summary/index.js';
 import type { UmbBlockGridValueModel } from '../../../types.js';
 export declare class UmbBlockGridPropertyEditorValueSummaryElement extends UmbValueSummaryElementBase<UmbBlockGridValueModel | undefined> {
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export { UmbBlockGridPropertyEditorValueSummaryElement as element };
 declare global {

package/dist-cms/packages/block/block-grid/workspace/views/block-grid-type-workspace-view-areas.element.d.ts

@@ -5,7 +5,7 @@ export declare class UmbBlockGridTypeWorkspaceViewAreasElement extends UmbLitEle
     private _areaColumnsConfigurationObject?;
     private _areaConfigConfigurationObject?;
     constructor();
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static styles: import("lit").CSSResult[];
 }
 export default UmbBlockGridTypeWorkspaceViewAreasElement;

package/dist-cms/packages/block/block-list/property-editors/block-list-editor/property-editor-ui-block-list.element.d.ts

@@ -28,7 +28,7 @@ export declare class UmbPropertyEditorUIBlockListElement extends UmbPropertyEdit
     private _isSortMode;
     constructor();
     protected getFormElement(): undefined;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static readonly styles: import("lit").CSSResult[];
 }
 export default UmbPropertyEditorUIBlockListElement;

package/dist-cms/packages/block/block-list/property-editors/block-list-editor/value-summary/value-summary.element.d.ts

@@ -2,7 +2,7 @@ import { nothing } from '../../../../../../external/lit/index.js';
 import { UmbValueSummaryElementBase } from '../../../../../core/value-summary/index.js';
 import type { UmbBlockListValueModel } from '../../../types.js';
 export declare class UmbBlockListPropertyEditorValueSummaryElement extends UmbValueSummaryElementBase<UmbBlockListValueModel | undefined> {
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export { UmbBlockListPropertyEditorValueSummaryElement as element };
 declare global {

package/dist-cms/packages/block/block-rte/property-editors/property-editor-ui-block-rte-type-configuration.element.d.ts

@@ -11,7 +11,7 @@ export declare class UmbPropertyEditorUIBlockRteBlockConfigurationElement extend
     config?: UmbPropertyEditorConfigCollection;
     private _workspacePath?;
     constructor();
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export default UmbPropertyEditorUIBlockRteBlockConfigurationElement;
 declare global {

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

@@ -31,7 +31,7 @@ export declare class UmbBlockSingleEntryElement extends UmbLitElement implements
     private _isReadOnly;
     constructor();
     connectedCallback(): void;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static styles: import("lit").CSSResult[];
 }
 export default UmbBlockSingleEntryElement;

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

@@ -26,7 +26,7 @@ export declare class UmbPropertyEditorUIBlockSingleElement extends UmbPropertyEd
     constructor();
     protected willUpdate(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
     protected getFormElement(): undefined;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static readonly styles: import("lit").CSSResult[];
 }
 export default UmbPropertyEditorUIBlockSingleElement;

package/dist-cms/packages/block/block-single/property-editors/block-single-editor/value-summary/value-summary.element.d.ts

@@ -2,7 +2,7 @@ import { nothing } from '../../../../../../external/lit/index.js';
 import { UmbValueSummaryElementBase } from '../../../../../core/value-summary/index.js';
 import type { UmbBlockSingleValueModel } from '../../../types.js';
 export declare class UmbBlockSinglePropertyEditorValueSummaryElement extends UmbValueSummaryElementBase<UmbBlockSingleValueModel | undefined> {
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export { UmbBlockSinglePropertyEditorValueSummaryElement as element };
 declare global {

package/dist-cms/packages/code-editor/property-editor/value-summary/value-summary.element.d.ts

@@ -1,7 +1,7 @@
 import { nothing } from '../../../../external/lit/index.js';
 import { UmbValueSummaryElementBase } from '../../../core/value-summary/index.js';
 export declare class UmbCodeEditorPropertyEditorValueSummaryElement extends UmbValueSummaryElementBase<string | undefined> {
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export { UmbCodeEditorPropertyEditorValueSummaryElement as element };
 declare global {

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

@@ -9,7 +9,7 @@ export default class UmbAuditLogActionElement<MetaType extends MetaAuditLogActio
     unique?: string | null;
     manifest?: ManifestAuditLogAction<MetaType>;
     set api(api: ApiType | undefined);
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export { UmbAuditLogActionElement as element };
 declare global {

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

@@ -184,9 +184,6 @@ let UmbContentAuditLogWorkspaceInfoAppElement = class UmbContentAuditLogWorkspac
 			}
 
 			uui-pagination {
-				flex: 1;
-				display: flex;
-				justify-content: center;
 				margin-top: var(--uui-size-layout-1);
 			}
 		`,

package/dist-cms/packages/content/content/collection/content-collection-workspace-view.element.d.ts

@@ -6,7 +6,7 @@ export declare class UmbContentCollectionWorkspaceViewElement extends UmbLitElem
     private _config?;
     private _collectionAlias?;
     constructor();
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export { UmbContentCollectionWorkspaceViewElement as element };
 declare global {

package/dist-cms/packages/content/content/global-components/content-workspace-property.element.d.ts

@@ -15,7 +15,7 @@ export declare class UmbContentWorkspacePropertyElement extends UmbLitElement {
     private _hasAccessToSensitiveData;
     constructor();
     willUpdate(changedProperties: Map<string, any>): void;
-    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 export default UmbContentWorkspacePropertyElement;
 declare global {