@umbraco-cms/backoffice 17.2.2 → 17.3.0-rc

package/dist-cms/packages/user/current-user/history/current-user-history-user-profile-app.element.js

@@ -5,14 +5,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { UMB_CURRENT_USER_HISTORY_STORE_CONTEXT } from './current-user-history.store.token.js';
-import { html, customElement, state, map, ifDefined, css } from '../../../../external/lit/index.js';
+import { html, customElement, state, nothing, css, repeat } from '../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../core/lit-element/index.js';
 import { UmbTextStyles } from '../../../core/style/index.js';
+import { UmbPaginationManager } from '../../../core/utils/index.js';
+const PAGE_SIZE = 10;
 let UmbCurrentUserHistoryUserProfileAppElement = class UmbCurrentUserHistoryUserProfileAppElement extends UmbLitElement {
     #currentUserHistoryStore;
+    #pagination;
     constructor() {
         super();
         this._history = [];
+        this._currentPageNumber = 1;
+        this._totalPages = 1;
+        this.#pagination = new UmbPaginationManager();
+        this.#pagination.setPageSize(PAGE_SIZE);
+        this.observe(this.#pagination.currentPage, (number) => (this._currentPageNumber = number));
+        this.observe(this.#pagination.totalPages, (number) => (this._totalPages = number));
         this.consumeContext(UMB_CURRENT_USER_HISTORY_STORE_CONTEXT, (instance) => {
             this.#currentUserHistoryStore = instance;
             this.#observeHistory();
@@ -22,34 +31,60 @@ let UmbCurrentUserHistoryUserProfileAppElement = class UmbCurrentUserHistoryUser
         if (this.#currentUserHistoryStore) {
             this.observe(this.#currentUserHistoryStore.latestHistory, (history) => {
                 this._history = history.reverse();
+                this.#pagination.setTotalItems(this._history.length);
             }, 'umbCurrentUserHistoryObserver');
         }
     }
+    #onPageChange(event) {
+        this.#pagination.setCurrentPageNumber(event.target.current);
+    }
+    #getCurrentPageItems() {
+        const skip = this.#pagination.getSkip();
+        return this._history.slice(skip, skip + PAGE_SIZE);
+    }
     #truncate(input, length, separator = '...') {
+        if (!input)
+            return '';
         if (input.length <= length)
             return input;
         const separatorLength = separator.length;
         const charsToShow = length - separatorLength;
         const frontChars = Math.ceil(charsToShow / 2);
         const backChars = Math.floor(charsToShow / 2);
-        return input.substring(9, frontChars) + separator + input.substring(input.length - backChars);
+        return input.substring(0, frontChars) + separator + input.substring(input.length - backChars);
     }
     render() {
         return html `
 			<uui-box headline=${this.localize.term('user_yourHistory')}>
-				<uui-ref-list>${map(this._history, (item) => html ` ${this.#renderItem(item)} `)}</uui-ref-list>
+				<uui-ref-list>
+					${repeat(this.#getCurrentPageItems(), (item) => item.unique, (item) => this.#renderItem(item))}
+				</uui-ref-list>
+				${this.#renderPagination()}
 			</uui-box>
 		`;
     }
     #renderItem(item) {
         const label = Array.isArray(item.label) ? item.label[0] : item.label;
-        const detail = Array.isArray(item.label) ? item.label.join(' > ') : this.#truncate(item.path, 50);
         return html `
-			<uui-ref-node name=${label} detail=${ifDefined(detail)} href=${item.path}>
+			<uui-ref-node name=${label} detail=${this.#truncate(item.displayPath, 50)} href=${item.path}>
 				<uui-icon slot="icon" name="icon-link"></uui-icon>
 			</uui-ref-node>
 		`;
     }
+    #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 `
@@ -57,12 +92,24 @@ let UmbCurrentUserHistoryUserProfileAppElement = class UmbCurrentUserHistoryUser
 				padding-left: 0;
 				padding-right: 0;
 			}
+
+			uui-pagination {
+				display: flex;
+				justify-content: center;
+				margin-top: var(--uui-size-layout-1);
+			}
 		`,
     ]; }
 };
 __decorate([
     state()
 ], UmbCurrentUserHistoryUserProfileAppElement.prototype, "_history", void 0);
+__decorate([
+    state()
+], UmbCurrentUserHistoryUserProfileAppElement.prototype, "_currentPageNumber", void 0);
+__decorate([
+    state()
+], UmbCurrentUserHistoryUserProfileAppElement.prototype, "_totalPages", void 0);
 UmbCurrentUserHistoryUserProfileAppElement = __decorate([
     customElement('umb-current-user-history-user-profile-app')
 ], UmbCurrentUserHistoryUserProfileAppElement);

package/dist-cms/packages/user/current-user/history/current-user-history.store.d.ts

@@ -1,14 +1,22 @@
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 import { UmbStoreBase } from '../../../core/store/index.js';
+/** @deprecated No longer used internally. This will be removed in Umbraco 19. [LK] */
 export type UmbModelType = 'dialog' | 'sidebar';
 export type UmbCurrentUserHistoryItem = {
     unique: string;
     path: string;
+    /** @deprecated `label` type will be changed to `string` only in Umbraco 19. [LK] */
     label: string | Array<string>;
+    /** @deprecated No longer used internally. This will be removed in Umbraco 19. [LK] */
     icon?: string;
+    displayPath?: string;
 };
 export declare class UmbCurrentUserHistoryStore extends UmbStoreBase<UmbCurrentUserHistoryItem> {
+    #private;
     readonly history: import("rxjs").Observable<UmbCurrentUserHistoryItem[]>;
+    /**
+     * Returns the latest 100 history items.
+     */
     readonly latestHistory: import("rxjs").Observable<UmbCurrentUserHistoryItem[]>;
     constructor(host: UmbControllerHost);
     /**
@@ -24,5 +32,6 @@ export declare class UmbCurrentUserHistoryStore extends UmbStoreBase<UmbCurrentU
      * @memberof UmbHistoryService
      */
     clear(): void;
+    destroy(): void;
 }
 export default UmbCurrentUserHistoryStore;

package/dist-cms/packages/user/current-user/history/current-user-history.store.js

@@ -3,21 +3,226 @@ import { UmbId } from '../../../core/id/index.js';
 import { UmbArrayState } from '../../../../libs/observable-api/index.js';
 import { UmbStoreBase } from '../../../core/store/index.js';
 export class UmbCurrentUserHistoryStore extends UmbStoreBase {
+    #lastAddedUnique;
+    #lastAddedPath;
+    #titleObserver;
+    #headObserver;
+    #titleUpdateTimer;
+    #handleNavigateSuccess;
+    #handleNavigate;
     constructor(host) {
         super(host, UMB_CURRENT_USER_HISTORY_STORE_CONTEXT.toString(), new UmbArrayState([], (x) => x.unique));
         this.history = this._data.asObservable();
-        this.latestHistory = this._data.asObservablePart((historyItems) => historyItems.slice(-10));
-        if (!('navigation' in window))
-            return;
-        window.navigation.addEventListener('navigate', (event) => {
+        /**
+         * Returns the latest 100 history items.
+         */
+        this.latestHistory = this._data.asObservablePart((historyItems) => historyItems.slice(-100));
+        this.#lastAddedUnique = null;
+        this.#lastAddedPath = null;
+        this.#titleObserver = null;
+        this.#headObserver = null;
+        this.#titleUpdateTimer = null;
+        this.#handleNavigateSuccess = () => {
+            // Update label for the most recent history item after navigation completes.
+            this.#scheduleTitleUpdate();
+        };
+        this.#handleNavigate = (event) => {
             const url = new URL(event.destination.url);
+            const path = this.#normalizePath(url.pathname);
+            // Before adding a new item, finalize the label of the previous item
+            // using the current document title (before it changes).
+            this.#finalizeCurrentLabel();
+            const unique = UmbId.new();
             const historyItem = {
-                unique: new UmbId().toString(),
-                path: url.pathname,
-                label: event.destination.url.split('/').pop(),
+                unique,
+                path,
+                displayPath: this.#formatDisplayPath(path),
+                label: this.#extractLabelFromPath(path),
             };
-            this.push(historyItem);
-        });
+            const wasAdded = this.#pushIfNew(historyItem);
+            if (wasAdded) {
+                this.#lastAddedUnique = unique;
+                this.#lastAddedPath = path;
+            }
+        };
+        if (!('navigation' in window))
+            return;
+        window.navigation.addEventListener('navigatesuccess', this.#handleNavigateSuccess);
+        window.navigation.addEventListener('navigate', this.#handleNavigate);
+        this.#setupTitleObserver();
+    }
+    /**
+     * Normalize a path by stripping sub-route suffixes (variants, views, tabs)
+     * and trailing /collection segments. This ensures that internal workspace
+     * navigation (e.g., switching tabs or variants) does not create separate
+     * history entries, while still creating an entry for the base entity path.
+     */
+    #normalizePath(path) {
+        // Strip sub-route suffixes: variant paths (/invariant, /en-us), /root
+        path = path.replace(/\/(?:invariant|root)(?:\/.*)?$/, '');
+        path = path.replace(/\/[a-z]{2}-[a-z]{2}(?:\/.*)?$/i, '');
+        // Strip view and tab sub-routes
+        path = path.replace(/\/(?:view|tab)(?:\/.*)?$/, '');
+        // Strip trailing /collection to de-duplicate with parent
+        path = path.replace(/\/collection$/, '');
+        return path;
+    }
+    /**
+     * Finalize the current item's label before navigating away.
+     * If the path ends in a GUID and the title wasn't resolved in time, remove the entry.
+     */
+    #finalizeCurrentLabel() {
+        if (this.#titleUpdateTimer) {
+            clearTimeout(this.#titleUpdateTimer);
+            this.#titleUpdateTimer = null;
+        }
+        this.#removeUnresolvedGuidEntry();
+    }
+    /**
+     * Remove the last added entry if it ends in a GUID and the label wasn't resolved from the title.
+     * This cleans up entries where the user navigated away too quickly.
+     */
+    #removeUnresolvedGuidEntry() {
+        if (!this.#lastAddedUnique || !this.#lastAddedPath)
+            return;
+        const lastSegment = this.#getLastPathSegment(this.#lastAddedPath);
+        if (!UmbId.validate(lastSegment))
+            return;
+        const items = this._data.getValue();
+        const item = items.find((i) => i.unique === this.#lastAddedUnique);
+        if (!item || item.label !== this.#extractLabelFromPath(this.#lastAddedPath))
+            return;
+        this._data.setValue(items.filter((i) => i.unique !== this.#lastAddedUnique));
+    }
+    /**
+     * Get the last segment of a path.
+     */
+    #getLastPathSegment(path) {
+        return path.split('/').filter(Boolean).pop() ?? '';
+    }
+    /**
+     * Extract a readable label from a path.
+     * Tries to get the last meaningful segment (usually entity ID or section name).
+     */
+    #extractLabelFromPath(path) {
+        return this.#formatSegmentAsLabel(this.#getLastPathSegment(path));
+    }
+    /**
+     * Format a URL segment as a readable label.
+     * Handles special suffixes and converts kebab-case to Title Case.
+     */
+    #formatSegmentAsLabel(segment) {
+        if (!segment)
+            return '';
+        // Special cases: Handle specific common and known segments to provide something more user-friendly.
+        if (segment === 'dashboardTabsContentIntro') {
+            return 'Welcome to Umbraco';
+        }
+        // Special cases: Handle known and common suffixes: "user-root" -> "Users", "member-management" -> "Members"
+        if (segment.endsWith('-root') || segment.endsWith('-management')) {
+            const base = segment.replace(/-(root|management)$/, '');
+            const titleCased = this.#toTitleCase(base);
+            return titleCased + 's';
+        }
+        // Convert kebab-case to Title Case for better display
+        // e.g., "models-builder" -> "Models Builder"
+        return this.#toTitleCase(segment);
+    }
+    /**
+     * Convert a kebab-case string to Title Case.
+     * e.g., "models-builder" -> "Models Builder"
+     */
+    #toTitleCase(str) {
+        if (!str)
+            return '';
+        return str
+            .split('-')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join(' ');
+    }
+    /**
+     * Format a path for display by stripping common prefixes.
+     * e.g., "/umbraco/section/content/..." -> "content/..."
+     */
+    #formatDisplayPath(path) {
+        return path.replace(/^\/(umbraco\/)?(section\/)?/, '');
+    }
+    #setupTitleObserver() {
+        const titleElement = document.querySelector('title');
+        if (titleElement) {
+            this.#titleObserver = new MutationObserver(() => this.#onTitleChange());
+            this.#titleObserver.observe(titleElement, { childList: true, characterData: true, subtree: true });
+        }
+        else {
+            // If title element doesn't exist yet, observe head for its creation.
+            this.#headObserver = new MutationObserver(() => {
+                const title = document.querySelector('title');
+                if (title) {
+                    this.#headObserver?.disconnect();
+                    this.#headObserver = null;
+                    this.#titleObserver = new MutationObserver(() => this.#onTitleChange());
+                    this.#titleObserver.observe(title, { childList: true, characterData: true, subtree: true });
+                }
+            });
+            this.#headObserver.observe(document.head, { childList: true });
+        }
+    }
+    #onTitleChange() {
+        this.#scheduleTitleUpdate();
+    }
+    #scheduleTitleUpdate() {
+        if (this.#titleUpdateTimer) {
+            clearTimeout(this.#titleUpdateTimer);
+        }
+        // Capture the target path at schedule time so the update only fires
+        // if we're still on the same page when the timer completes.
+        // This prevents updating the wrong entry during fast navigation.
+        const targetPath = this.#lastAddedPath;
+        this.#titleUpdateTimer = setTimeout(() => {
+            if (targetPath && this.#normalizePath(window.location.pathname) === targetPath) {
+                this.#updateLatestLabel();
+            }
+        }, 150);
+    }
+    #updateLatestLabel() {
+        if (!this.#lastAddedUnique || !this.#lastAddedPath)
+            return;
+        const title = document.title;
+        if (!title)
+            return;
+        // Extract friendly title by removing " | Umbraco" suffix.
+        let friendlyTitle = title.replace(/ \| Umbraco$/, '');
+        if (!friendlyTitle)
+            return;
+        // Take only the first part if there are multiple pipe-separated segments
+        // e.g., "My Blog Post | Content" -> "My Blog Post".
+        const pipeIndex = friendlyTitle.indexOf(' | ');
+        if (pipeIndex > 0) {
+            friendlyTitle = friendlyTitle.substring(0, pipeIndex);
+        }
+        // Skip generic/technical labels that aren't useful as entity names.
+        const skipLabels = ['invariant', 'content', 'media', 'settings', 'users', 'packages', 'members', 'user'];
+        if (skipLabels.includes(friendlyTitle.toLowerCase())) {
+            return;
+        }
+        // Update the item in the store for immediate display
+        this.updateItem(this.#lastAddedUnique, { label: friendlyTitle });
+    }
+    /**
+     * Pushes a new history item, removing any existing item with the same path.
+     * @returns true if the item was added, false if it was a duplicate of the last item
+     */
+    #pushIfNew(historyItem) {
+        const history = this._data.getValue();
+        const lastItem = history[history.length - 1];
+        // Skip if this is the same as the last item (immediate duplicate).
+        if (lastItem && lastItem.path === historyItem.path) {
+            return false;
+        }
+        // Remove any earlier entry with the same path (de-duplicate).
+        const filteredHistory = history.filter((item) => item.path !== historyItem.path);
+        this._data.setValue([...filteredHistory, historyItem]);
+        return true;
     }
     /**
      * Pushes a new history item to the history array
@@ -26,12 +231,7 @@ export class UmbCurrentUserHistoryStore extends UmbStoreBase {
      * @memberof UmbHistoryService
      */
     push(historyItem) {
-        const history = this._data.getValue();
-        const lastItem = history[history.length - 1];
-        // This prevents duplicate entries in the history array.
-        if (!lastItem || lastItem.path !== historyItem.path) {
-            this._data.setValue([...this._data.getValue(), historyItem]);
-        }
+        this.#pushIfNew(historyItem);
     }
     /**
      * Clears the history array
@@ -40,6 +240,27 @@ export class UmbCurrentUserHistoryStore extends UmbStoreBase {
      */
     clear() {
         this._data.setValue([]);
+        this.#lastAddedUnique = null;
+        this.#lastAddedPath = null;
+    }
+    destroy() {
+        if ('navigation' in window) {
+            window.navigation.removeEventListener('navigatesuccess', this.#handleNavigateSuccess);
+            window.navigation.removeEventListener('navigate', this.#handleNavigate);
+        }
+        if (this.#headObserver) {
+            this.#headObserver.disconnect();
+            this.#headObserver = null;
+        }
+        if (this.#titleObserver) {
+            this.#titleObserver.disconnect();
+            this.#titleObserver = null;
+        }
+        if (this.#titleUpdateTimer) {
+            clearTimeout(this.#titleUpdateTimer);
+            this.#titleUpdateTimer = null;
+        }
+        super.destroy();
     }
 }
 // Default export for the globalContext manifest:

package/dist-cms/packages/user/current-user/modals/current-user/current-user-modal.element.js

@@ -10,7 +10,6 @@ import { UmbTextStyles } from '../../../../core/style/index.js';
 import { css, html, customElement, property, state } from '../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../../core/lit-element/index.js';
 let UmbCurrentUserModalElement = class UmbCurrentUserModalElement extends UmbLitElement {
-    #authContext;
     #currentUserContext;
     constructor() {
         super();
@@ -18,9 +17,6 @@ let UmbCurrentUserModalElement = class UmbCurrentUserModalElement extends UmbLit
             this.#currentUserContext = instance;
             this._observeCurrentUser();
         });
-        this.consumeContext(UMB_AUTH_CONTEXT, (instance) => {
-            this.#authContext = instance;
-        });
     }
     async _observeCurrentUser() {
         if (!this.#currentUserContext)
@@ -33,10 +29,12 @@ let UmbCurrentUserModalElement = class UmbCurrentUserModalElement extends UmbLit
         this.modalContext?.submit();
     }
     async _logout() {
-        if (!this.#authContext)
-            return;
+        const authContext = await this.getContext(UMB_AUTH_CONTEXT);
+        if (!authContext) {
+            throw new Error('UMB_AUTH_CONTEXT could not be retrieved, this is required to log out the user.');
+        }
         this._logOutButtonState = 'waiting';
-        await this.#authContext.signOut();
+        await authContext.signOut();
         this._logOutButtonState = 'success';
     }
     render() {

package/dist-cms/packages/user/user/repository/item/user-item.server.request-manager.d.ts

@@ -2,5 +2,6 @@ import type { UmbControllerHost } from '../../../../../libs/controller-api/index
 import { type UserItemResponseModel } from '../../../../core/backend-api/index.js';
 import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
 export declare class UmbManagementApiUserItemDataRequestManager extends UmbManagementApiItemDataRequestManager<UserItemResponseModel> {
+    #private;
     constructor(host: UmbControllerHost);
 }

package/dist-cms/packages/user/user/repository/item/user-item.server.request-manager.js

@@ -1,12 +1,14 @@
 /* eslint-disable local-rules/no-direct-api-import */
 import { userItemCache } from './user-item.server.cache.js';
 import { UserService } from '../../../../core/backend-api/index.js';
-import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
+import { UmbManagementApiItemDataRequestManager, UmbManagementApiInFlightRequestCache, } from '../../../../management-api/index.js';
 export class UmbManagementApiUserItemDataRequestManager extends UmbManagementApiItemDataRequestManager {
+    static #inflightRequestCache = new UmbManagementApiInFlightRequestCache();
     constructor(host) {
         super(host, {
             getItems: (ids) => UserService.getItemUser({ query: { id: ids } }),
             dataCache: userItemCache,
+            inflightRequestCache: UmbManagementApiUserItemDataRequestManager.#inflightRequestCache,
             getUniqueMethod: (item) => item.id,
         });
     }

package/dist-cms/packages/user/user/workspace/user/components/user-workspace-assign-access/user-workspace-assign-access.element.js

@@ -137,6 +137,7 @@ let UmbUserWorkspaceAssignAccessElement = class UmbUserWorkspaceAssignAccessElem
             ? html `
 							<umb-input-media
 								slot="editor"
+								folder-filter="foldersOnly"
 								.selection=${this._mediaStartNodeUniques.map((reference) => reference.unique)}
 								@change=${this.#onMediaStartNodeChange}></umb-input-media>
 						`

package/dist-cms/packages/user/user/workspace/user/user-workspace.context.js

@@ -52,14 +52,17 @@ export class UmbUserWorkspaceContext extends UmbEntityNamedDetailWorkspaceContex
         this.#calculatedStartNodes.setValue(calculatedStartNodes);
         return response;
     }
-    /* TODO: some properties are allowed to update without saving.
-        For a user properties like state will be updated when one of the entity actions are executed.
+    /* Some properties are allowed to update without saving.
+        For a user, properties like state will be updated when one of the entity actions are executed.
         Therefore we have to subscribe to the user store to update the state in the workspace data.
+        We update both current and persisted so these server-applied changes do not trigger dirty state.
         There might be a less manual way to do this.
     */
     onUserStoreChanges(user) {
         if (user) {
-            this._data.updateCurrent({ state: user.state, avatarUrls: user.avatarUrls });
+            const serverAppliedChanges = { state: user.state, avatarUrls: user.avatarUrls };
+            this._data.updateCurrent(serverAppliedChanges);
+            this._data.updatePersisted(serverAppliedChanges);
         }
     }
     getState() {

package/dist-cms/packages/user/user-group/repository/item/user-group-item.server.request-manager.d.ts

@@ -2,5 +2,6 @@ import type { UmbControllerHost } from '../../../../../libs/controller-api/index
 import { type UserGroupItemResponseModel } from '../../../../core/backend-api/index.js';
 import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
 export declare class UmbManagementApiUserGroupItemDataRequestManager extends UmbManagementApiItemDataRequestManager<UserGroupItemResponseModel> {
+    #private;
     constructor(host: UmbControllerHost);
 }

package/dist-cms/packages/user/user-group/repository/item/user-group-item.server.request-manager.js

@@ -1,12 +1,14 @@
 /* eslint-disable local-rules/no-direct-api-import */
 import { userGroupItemCache } from './user-group-item.server.cache.js';
 import { UserGroupService } from '../../../../core/backend-api/index.js';
-import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
+import { UmbManagementApiItemDataRequestManager, UmbManagementApiInFlightRequestCache, } from '../../../../management-api/index.js';
 export class UmbManagementApiUserGroupItemDataRequestManager extends UmbManagementApiItemDataRequestManager {
+    static #inflightRequestCache = new UmbManagementApiInFlightRequestCache();
     constructor(host) {
         super(host, {
             getItems: (ids) => UserGroupService.getItemUserGroup({ query: { id: ids } }),
             dataCache: userGroupItemCache,
+            inflightRequestCache: UmbManagementApiUserGroupItemDataRequestManager.#inflightRequestCache,
             getUniqueMethod: (item) => item.id,
         });
     }

package/dist-cms/packages/user/user-group/workspace/user-group/views/user-group-details-workspace-view.element.js

@@ -175,6 +175,7 @@ let UmbUserGroupDetailsWorkspaceViewElement = class UmbUserGroupDetailsWorkspace
 							<umb-input-media
 								slot="editor"
 								max="1"
+								folder-filter="foldersOnly"
 								.selection=${this._mediaStartNode?.unique ? [this._mediaStartNode.unique] : []}
 								@change=${this.#onMediaStartNodeChange}></umb-input-media>
 						`

package/dist-cms/packages/webhook/webhook/repository/item/webhook-item.server.request-manager.d.ts

@@ -2,5 +2,6 @@ import type { UmbControllerHost } from '../../../../../libs/controller-api/index
 import { type WebhookItemResponseModel } from '../../../../core/backend-api/index.js';
 import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
 export declare class UmbManagementApiWebhookItemDataRequestManager extends UmbManagementApiItemDataRequestManager<WebhookItemResponseModel> {
+    #private;
     constructor(host: UmbControllerHost);
 }

package/dist-cms/packages/webhook/webhook/repository/item/webhook-item.server.request-manager.js

@@ -1,12 +1,14 @@
 /* eslint-disable local-rules/no-direct-api-import */
 import { webhookItemCache } from './webhook-item.server.cache.js';
 import { WebhookService } from '../../../../core/backend-api/index.js';
-import { UmbManagementApiItemDataRequestManager } from '../../../../management-api/index.js';
+import { UmbManagementApiItemDataRequestManager, UmbManagementApiInFlightRequestCache, } from '../../../../management-api/index.js';
 export class UmbManagementApiWebhookItemDataRequestManager extends UmbManagementApiItemDataRequestManager {
+    static #inflightRequestCache = new UmbManagementApiInFlightRequestCache();
     constructor(host) {
         super(host, {
             getItems: (ids) => WebhookService.getItemWebhook({ query: { id: ids } }),
             dataCache: webhookItemCache,
+            inflightRequestCache: UmbManagementApiWebhookItemDataRequestManager.#inflightRequestCache,
             getUniqueMethod: (item) => item.id,
         });
     }