@umbraco-cms/backoffice 17.2.2 → 17.3.0-rc

package/dist-cms/packages/core/property-editor/ui-picker-modal/property-editor-ui-picker-modal.element.js

@@ -81,19 +81,27 @@ let UmbPropertyEditorUIPickerModalElement = class UmbPropertyEditorUIPickerModal
     #renderGroupItems(groupItems) {
         return html `
 			<ul id="item-grid">
-				${repeat(groupItems, (propertyEditorUI) => propertyEditorUI.alias, (propertyEditorUI) => html `
-						<li class="item" ?selected=${this.value.selection.includes(propertyEditorUI.alias)}>
-							<button type="button" @click=${() => this.#handleClick(propertyEditorUI)}>
-								<umb-icon name=${propertyEditorUI.meta.icon} class="icon"></umb-icon>
-								${this.localize.string(propertyEditorUI.meta.label || propertyEditorUI.name)}
-							</button>
-						</li>
-					`)}
+				${repeat(groupItems, (propertyEditorUI) => propertyEditorUI.alias, (propertyEditorUI) => {
+            const label = this.localize.string(propertyEditorUI.meta.label || propertyEditorUI.name);
+            return html `
+							<li class="item" ?selected=${this.value.selection.includes(propertyEditorUI.alias)}>
+								<button type="button" @click=${() => this.#handleClick(propertyEditorUI)}>
+									<umb-icon name=${propertyEditorUI.meta.icon} class="icon"></umb-icon>
+									<span class="label" title=${label}>${label}</span>
+								</button>
+							</li>
+						`;
+        })}
 			</ul>
 		`;
     }
     static { this.styles = [
         css `
+			:host {
+				display: block;
+				container-type: inline-size;
+			}
+
 			#filter {
 				width: 100%;
 				margin-bottom: var(--uui-size-space-4);
@@ -108,12 +116,30 @@ let UmbPropertyEditorUIPickerModalElement = class UmbPropertyEditorUIPickerModal
 
 			#item-grid {
 				display: grid;
-				grid-template-columns: repeat(auto-fill, minmax(70px, 1fr));
+				grid-template-columns: repeat(3, minmax(0, 1fr));
 				margin: 0;
 				padding: 0;
 				grid-gap: var(--uui-size-space-4);
 			}
 
+			@container (min-width: 560px) {
+				#item-grid {
+					grid-template-columns: repeat(4, minmax(0, 1fr));
+				}
+			}
+
+			@container (min-width: 740px) {
+				#item-grid {
+					grid-template-columns: repeat(5, minmax(0, 1fr));
+				}
+			}
+
+			@container (min-width: 920px) {
+				#item-grid {
+					grid-template-columns: repeat(6, minmax(0, 1fr));
+				}
+			}
+
 			#item-grid .item {
 				display: flex;
 				align-items: flex-start;
@@ -143,7 +169,7 @@ let UmbPropertyEditorUIPickerModalElement = class UmbPropertyEditorUIPickerModal
 				display: flex;
 				align-items: center;
 				flex-direction: column;
-				justify-content: center;
+				justify-content: flex-start;
 				font-size: 0.8rem;
 				height: 100%;
 				width: 100%;
@@ -155,6 +181,14 @@ let UmbPropertyEditorUIPickerModalElement = class UmbPropertyEditorUIPickerModal
 				font-size: 2em;
 				margin-bottom: var(--uui-size-space-2);
 			}
+
+			#item-grid .item .label {
+				max-width: 100%;
+				display: -webkit-box;
+				-webkit-line-clamp: 2;
+				-webkit-box-orient: vertical;
+				overflow: hidden;
+			}
 		`,
     ]; }
 };

package/dist-cms/packages/core/property-editor/ui-picker-modal/property-editor-ui-picker-modal.token.js

@@ -2,6 +2,6 @@ import { UmbModalToken } from '../../modal/index.js';
 export const UMB_PROPERTY_EDITOR_UI_PICKER_MODAL = new UmbModalToken('Umb.Modal.PropertyEditorUiPicker', {
     modal: {
         type: 'sidebar',
-        size: 'small',
+        size: 'medium',
     },
 });

package/dist-cms/packages/core/recycle-bin/entity-action/restore-from-recycle-bin/restore-from-recycle-bin.action.kind.js

@@ -13,7 +13,7 @@ export const manifest = {
         forEntityTypes: [],
         meta: {
             icon: 'icon-undo',
-            label: 'Restore',
+            label: '#actions_restore',
             pickerModal: '',
             additionalOptions: true,
         },

package/dist-cms/packages/core/repository/detail/read/read-detail-data-source.interface.d.ts

@@ -5,4 +5,5 @@ export interface UmbReadDetailDataSourceConstructor<DetailType = any> {
 }
 export interface UmbReadDetailDataSource<DetailType> {
     read(unique: string): Promise<UmbDataSourceResponse<DetailType>>;
+    readMany?(uniques: Array<string>): Promise<UmbDataSourceResponse<Array<DetailType>>>;
 }

package/dist-cms/packages/core/repository/detail/read/read-detail-repository.interface.d.ts

@@ -3,5 +3,6 @@ import type { UmbApi } from '../../../../../libs/extension-api/index.js';
 import type { Observable } from '../../../../../external/rxjs/index.js';
 export interface UmbReadDetailRepository<DetailModelType> extends UmbApi {
     requestByUnique(unique: string): Promise<UmbRepositoryResponseWithAsObservable<DetailModelType | undefined>>;
+    requestByUniques?(uniques: Array<string>): Promise<UmbRepositoryResponseWithAsObservable<Array<DetailModelType> | undefined>>;
     byUnique?(unique: string): Promise<Observable<DetailModelType | undefined>>;
 }

package/dist-cms/packages/core/repository/repository-details.manager.js

@@ -120,13 +120,15 @@ export class UmbRepositoryDetailsManager extends UmbControllerBase {
     addEntry(data) {
         const unique = data.unique;
         this.#entries.appendOne(data);
-        this.#uniques.appendOne(unique);
+        // Add status BEFORE unique to prevent #requestNewDetails from trying to fetch
+        // (the observation callback on #uniques checks #statuses to skip already-loaded entries)
         this.#statuses.appendOne({
             state: {
                 type: 'success',
             },
             unique,
         });
+        this.#uniques.appendOne(unique);
         // Notice in this case we do not have a observable from the repo, but it should maybe be fine that we just listen for ACTION EVENTS.
     }
     /**
@@ -156,9 +158,66 @@ export class UmbRepositoryDetailsManager extends UmbControllerBase {
             const item = this.#statuses.getValue().find((status) => status.unique === unique);
             return !item;
         });
-        newRequestedUniques.forEach((unique) => {
-            this.#requestDetails(unique);
-        });
+        if (newRequestedUniques.length === 0)
+            return;
+        // Use bulk endpoint when available, fall back to individual requests
+        if (this.repository.requestByUniques) {
+            this.#requestDetailsBulk(newRequestedUniques);
+        }
+        else {
+            newRequestedUniques.forEach((unique) => {
+                this.#requestDetails(unique);
+            });
+        }
+    }
+    async #requestDetailsBulk(uniques) {
+        await this.#init;
+        if (!this.repository?.requestByUniques)
+            throw new Error('Repository does not support requestByUniques');
+        for (const unique of uniques) {
+            this.#setStatus(unique, 'loading');
+        }
+        const { data, error, asObservable } = await this.repository.requestByUniques(uniques);
+        if (error) {
+            for (const unique of uniques) {
+                this.#setError(unique);
+            }
+            return;
+        }
+        if (data) {
+            const currentUniques = this.getUniques();
+            for (const unique of uniques) {
+                // Check it still exists in uniques (may have been removed while request was in flight)
+                if (!currentUniques.includes(unique)) {
+                    this.#statuses.removeOne(unique);
+                    continue;
+                }
+                const item = data.find((d) => d.unique === unique);
+                if (item) {
+                    this.#setSuccess(unique, item);
+                }
+                else {
+                    // Item was requested but not returned — treat as not found
+                    this.#setError(unique);
+                }
+            }
+            // Set up per-item store observation for reactivity
+            const successUniques = uniques.filter((u) => currentUniques.includes(u) && data.some((d) => d.unique === u));
+            for (const unique of successUniques) {
+                const observable = asObservable?.();
+                if (observable) {
+                    this.observe(observable, (items) => {
+                        const item = items?.find((d) => d.unique === unique);
+                        if (item) {
+                            this.#entries.updateOne(unique, item);
+                        }
+                        else {
+                            this.#entries.removeOne(unique);
+                        }
+                    }, 'observeEntry_' + unique);
+                }
+            }
+        }
     }
     async #reloadDetails(unique) {
         return await this.#requestDetails(unique);
@@ -167,50 +226,56 @@ export class UmbRepositoryDetailsManager extends UmbControllerBase {
         await this.#init;
         if (!this.repository)
             throw new Error('Repository is not initialized');
-        this.#statuses.appendOne({
-            state: {
-                type: 'loading',
-            },
-            unique,
-        });
+        this.#setStatus(unique, 'loading');
         const { data, error, asObservable } = await this.repository.requestByUnique(unique);
         if (error) {
-            this.#statuses.appendOne({
-                state: {
-                    type: 'error',
-                    error: '#general_notFound',
-                },
-                unique,
-            });
-            this.#entries.removeOne(unique);
-            this.removeUmbControllerByAlias('observeEntry_' + unique);
+            this.#setError(unique);
         }
         if (data) {
-            //Check it still exists in uniques:
+            // Check it still exists in uniques:
             const uniques = this.getUniques();
             if (!uniques.includes(unique)) {
                 this.#statuses.removeOne(unique);
                 return;
             }
-            this.#entries.appendOne(data);
-            this.#statuses.appendOne({
-                state: {
-                    type: 'success',
-                },
-                unique,
-            });
-            if (asObservable) {
-                this.observe(asObservable(), (data) => {
-                    if (data) {
-                        this.#entries.updateOne(unique, data);
-                    }
-                    else {
-                        this.#entries.removeOne(unique);
-                    }
-                }, 'observeEntry_' + unique);
+            this.#setSuccess(unique, data);
+            const observable = asObservable?.();
+            if (observable) {
+                this.#observeEntry(unique, observable);
             }
         }
     }
+    #setStatus(unique, type) {
+        this.#statuses.appendOne({
+            state: { type },
+            unique,
+        });
+    }
+    #setError(unique) {
+        this.#statuses.appendOne({
+            state: {
+                type: 'error',
+                error: '#general_notFound',
+            },
+            unique,
+        });
+        this.#entries.removeOne(unique);
+        this.removeUmbControllerByAlias('observeEntry_' + unique);
+    }
+    #setSuccess(unique, data) {
+        this.#entries.appendOne(data);
+        this.#setStatus(unique, 'success');
+    }
+    #observeEntry(unique, observable) {
+        this.observe(observable, (data) => {
+            if (data) {
+                this.#entries.updateOne(unique, data);
+            }
+            else {
+                this.#entries.removeOne(unique);
+            }
+        }, 'observeEntry_' + unique);
+    }
     #onEntityUpdatedEvent;
     destroy() {
         this.#eventContext?.removeEventListener(UmbEntityUpdatedEvent.TYPE, this.#onEntityUpdatedEvent);

package/dist-cms/packages/core/resources/api-interceptor.controller.d.ts

@@ -9,7 +9,7 @@ export declare class UmbApiInterceptorController extends UmbControllerBase {
      */
     bindDefaultInterceptors(client: typeof umbHttpClient): void;
     /**
-     * Interceptor which checks responses for 401 errors and lets the UmbAuthContext know the user is timed out.
+     * Interceptor which checks responses for 401 errors and signals the auth layer to show the login UI.
      * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response and Request interceptors.
      * @internal
      */
@@ -39,9 +39,9 @@ export declare class UmbApiInterceptorController extends UmbControllerBase {
      */
     addUmbNotificationsInterceptor(client: typeof umbHttpClient): void;
     /**
-     * Listen for authorization signal to retry GET-requests that received a 401 Unauthorized response.
-     * This will retry all pending requests that received a 401 Unauthorized response after re-authentication.
-     * It will also notify the user about non-GET requests that received a 401 Unauthorized response.
+     * Observes the auth signaler's authorization state to retry GET-requests that received a 401
+     * Unauthorized response. Also notifies the user about non-GET requests that received a 401
+     * Unauthorized response after re-authentication completes.
      * @internal
      */
     handleUnauthorizedAuthRetry(): void;

package/dist-cms/packages/core/resources/api-interceptor.controller.js

@@ -1,8 +1,8 @@
 import { extractUmbNotificationColor } from './extractUmbNotificationColor.function.js';
 import { isUmbNotifications, UMB_NOTIFICATION_HEADER } from './isUmbNotifications.function.js';
 import { isProblemDetailsLike } from './apiTypeValidators.function.js';
+import { UmbAuthSignalerContext } from './auth-signaler.context.js';
 import { UmbControllerBase } from '../../../libs/class-api/index.js';
-import { UMB_AUTH_CONTEXT } from '../auth/index.js';
 const MAX_RETRIES = 3;
 export class UmbApiInterceptorController extends UmbControllerBase {
     /**
@@ -17,6 +17,8 @@ export class UmbApiInterceptorController extends UmbControllerBase {
      * Instead, we will notify the user about these requests after re-authentication.
      */
     #nonGet401Requests = [];
+    /** Registered on the host so auth context can consume it to bridge authorization state. */
+    #signaler = new UmbAuthSignalerContext(this._host);
     /**
      * Binds the default interceptors to the client.
      * This includes the auth response interceptor, the error interceptor and the umb-notifications interceptor.
@@ -33,7 +35,7 @@ export class UmbApiInterceptorController extends UmbControllerBase {
         this.addErrorInterceptor(client);
     }
     /**
-     * Interceptor which checks responses for 401 errors and lets the UmbAuthContext know the user is timed out.
+     * Interceptor which checks responses for 401 errors and signals the auth layer to show the login UI.
      * @param {umbHttpClient} client The OpenAPI client to add the interceptor to. It can be any client supporting Response and Request interceptors.
      * @internal
      */
@@ -51,15 +53,13 @@ export class UmbApiInterceptorController extends UmbControllerBase {
                 stack: undefined,
             };
             const newResponse = this.#createResponse(problemDetails, response);
-            const authContext = await this.getContext(UMB_AUTH_CONTEXT, { preventTimeout: true });
-            if (!authContext)
-                throw new Error('Could not get the auth context');
+            const signaler = this.#signaler;
             // Only retry for GET requests
             if (request.method !== 'GET') {
                 // Collect info for later notification
                 this.#nonGet401Requests.push({ request, requestConfig });
-                // Show login overlay (only once per burst, as before)
-                authContext.timeOut();
+                // Signal the auth layer to show the login UI
+                signaler.requestTimeout();
                 return newResponse;
             }
             // Find if this request is already in the queue and increment retries
@@ -85,8 +85,8 @@ export class UmbApiInterceptorController extends UmbControllerBase {
                     reject,
                     retries,
                 });
-                // Show login overlay
-                authContext.timeOut();
+                // Signal the auth layer to show the login UI
+                signaler.requestTimeout();
                 console.log('[Interceptor] 401 Unauthorized - queuing request for re-authentication and have tried', retries - 1, 'times before', requestConfig);
             });
         });
@@ -211,32 +211,36 @@ export class UmbApiInterceptorController extends UmbControllerBase {
         });
     }
     /**
-     * Listen for authorization signal to retry GET-requests that received a 401 Unauthorized response.
-     * This will retry all pending requests that received a 401 Unauthorized response after re-authentication.
-     * It will also notify the user about non-GET requests that received a 401 Unauthorized response.
+     * Observes the auth signaler's authorization state to retry GET-requests that received a 401
+     * Unauthorized response. Also notifies the user about non-GET requests that received a 401
+     * Unauthorized response after re-authentication completes.
      * @internal
      */
     handleUnauthorizedAuthRetry() {
-        this.consumeContext(UMB_AUTH_CONTEXT, (context) => {
-            this.observe(context?.authorizationSignal, () => {
-                console.log('[Interceptor] 401 Unauthorized - re-authentication completed');
-                // On auth, retry all pending requests
-                const requests = this.#pending401Requests.splice(0, this.#pending401Requests.length);
-                requests.forEach((req) => {
-                    console.log('[Interceptor] 401 Unauthorized - retrying request after re-authentication', req.requestConfig);
-                    req.retry().then(req.resolve).catch(req.reject);
+        this.observe(this.#signaler.isAuthorized, (isAuthorized) => {
+            // Only retry when transitioning to authorized (i.e. re-authentication completed)
+            if (!isAuthorized)
+                return;
+            // Skip if there are no pending requests to retry
+            if (this.#pending401Requests.length === 0 && this.#nonGet401Requests.length === 0)
+                return;
+            console.log('[Interceptor] 401 Unauthorized - re-authentication completed');
+            // On auth, retry all pending requests
+            const requests = this.#pending401Requests.splice(0, this.#pending401Requests.length);
+            requests.forEach((req) => {
+                console.log('[Interceptor] 401 Unauthorized - retrying request after re-authentication', req.requestConfig);
+                req.retry().then(req.resolve).catch(req.reject);
+            });
+            // Notify about non-GET 401s after successful re-auth
+            if (this.#nonGet401Requests.length > 0) {
+                const errors = {};
+                this.#nonGet401Requests.forEach((req) => {
+                    errors[`${req.request.method} ${req.request.url}`] = `Request failed with 401 Unauthorized.`;
                 });
-                // Notify about non-GET 401s after successful re-auth
-                if (this.#nonGet401Requests.length > 0) {
-                    const errors = {};
-                    this.#nonGet401Requests.forEach((req) => {
-                        errors[`${req.request.method} ${req.request.url}`] = `Request failed with 401 Unauthorized.`;
-                    });
-                    this.#peekError('Some actions were not completed', 'Some actions could not be completed because your session expired. Please try again.', errors, 'warning');
-                    this.#nonGet401Requests.length = 0; // Clear after notifying
-                }
-            }, '_authClearNonGet401Requests');
-        });
+                this.#peekError('Some actions were not completed', 'Some actions could not be completed because your session expired. Please try again.', errors, 'warning');
+                this.#nonGet401Requests.length = 0; // Clear after notifying
+            }
+        }, '_authClearNonGet401Requests');
     }
     /**
      * Helper to create a new Response with correct Content-Type.
@@ -266,10 +270,10 @@ export class UmbApiInterceptorController extends UmbControllerBase {
     }
     /**
      * Helper to show a notification error.
-     * @param headline
-     * @param message
-     * @param details
-     * @param color
+     * @param {string} headline The headline of the error notification.
+     * @param {string} message The message of the error notification.
+     * @param {unknown} details Additional details to show in the notification.
+     * @param {UmbNotificationColor} [color] The color of the notification.
      */
     async #peekError(headline, message, details, color) {
         // Store the host for usage in the following async context

package/dist-cms/packages/core/resources/auth-signaler.context.d.ts

@@ -0,0 +1,20 @@
+import { UmbContextBase } from '../../../libs/class-api/index.js';
+import type { UmbControllerHost } from '../../../libs/controller-api/index.js';
+import { UmbContextToken } from '../../../libs/context-api/index.js';
+export declare const UMB_AUTH_SIGNALER_CONTEXT: UmbContextToken<UmbAuthSignalerContext, UmbAuthSignalerContext>;
+/**
+ * A lightweight bridge context owned by {@link UmbApiInterceptorController} (resources package)
+ * and consumed by the auth package. Allows resource-layer concerns (e.g. HTTP interceptors) to
+ * signal authentication state without creating a circular dependency on the auth package.
+ */
+export declare class UmbAuthSignalerContext extends UmbContextBase {
+    #private;
+    readonly isAuthorized: import("rxjs").Observable<boolean>;
+    /** Emits when an HTTP interceptor detects a 401 and needs the auth layer to show the login UI. */
+    readonly timeoutRequest: import("rxjs").Observable<void>;
+    constructor(host: UmbControllerHost);
+    /** Called by the auth context to keep authorization state in sync. */
+    setAuthorized(value: boolean): void;
+    /** Called by HTTP interceptors when a 401 response is received. */
+    requestTimeout(): void;
+}

package/dist-cms/packages/core/resources/auth-signaler.context.js

@@ -0,0 +1,30 @@
+import { UmbContextBase } from '../../../libs/class-api/index.js';
+import { UmbContextToken } from '../../../libs/context-api/index.js';
+import { UmbBooleanState } from '../../../libs/observable-api/index.js';
+import { Subject } from '../../../external/rxjs/index.js';
+export const UMB_AUTH_SIGNALER_CONTEXT = new UmbContextToken('UmbAuthSignalerContext');
+/**
+ * A lightweight bridge context owned by {@link UmbApiInterceptorController} (resources package)
+ * and consumed by the auth package. Allows resource-layer concerns (e.g. HTTP interceptors) to
+ * signal authentication state without creating a circular dependency on the auth package.
+ */
+export class UmbAuthSignalerContext extends UmbContextBase {
+    #isAuthorized;
+    #timeoutRequest;
+    constructor(host) {
+        super(host, UMB_AUTH_SIGNALER_CONTEXT);
+        this.#isAuthorized = new UmbBooleanState(false);
+        this.isAuthorized = this.#isAuthorized.asObservable();
+        this.#timeoutRequest = new Subject();
+        /** Emits when an HTTP interceptor detects a 401 and needs the auth layer to show the login UI. */
+        this.timeoutRequest = this.#timeoutRequest.asObservable();
+    }
+    /** Called by the auth context to keep authorization state in sync. */
+    setAuthorized(value) {
+        this.#isAuthorized.setValue(value);
+    }
+    /** Called by HTTP interceptors when a 401 response is received. */
+    requestTimeout() {
+        this.#timeoutRequest.next();
+    }
+}

package/dist-cms/packages/core/resources/extractUmbNotificationColor.function.d.ts

@@ -1,4 +1,4 @@
-import type { UmbNotificationColor } from '../notification/types.js';
+import type { UmbNotificationColor } from '../notification/index.js';
 import { EventMessageTypeModel } from '../backend-api/index.js';
 /**
  * Extracts the UmbNotificationColor from the EventMessageTypeModel.

package/dist-cms/packages/core/resources/index.d.ts

@@ -1,5 +1,6 @@
 export * from './api-interceptor.controller.js';
 export * from './apiTypeValidators.function.js';
+export * from './auth-signaler.context.js';
 export * from './extractUmbColorVariable.function.js';
 export * from './extractUmbNotificationColor.function.js';
 export * from './isUmbNotifications.function.js';

package/dist-cms/packages/core/resources/index.js

@@ -1,5 +1,6 @@
 export * from './api-interceptor.controller.js';
 export * from './apiTypeValidators.function.js';
+export * from './auth-signaler.context.js';
 export * from './extractUmbColorVariable.function.js';
 export * from './extractUmbNotificationColor.function.js';
 export * from './isUmbNotifications.function.js';

package/dist-cms/packages/core/resources/isUmbNotifications.function.d.ts

@@ -5,8 +5,9 @@ export interface UmbNotificationsEventModel {
     type: EventMessageTypeModel;
 }
 /**
- *
- * @param notifications
+ * Checks if an array of unknown values are all valid UmbNotificationsEventModel objects.
+ * @param {Array<unknown>} notifications The array to check.
+ * @returns {boolean} True if all items are valid UmbNotificationsEventModel objects.
  */
 export declare function isUmbNotifications(notifications: Array<unknown>): notifications is Array<UmbNotificationsEventModel>;
 export declare const UMB_NOTIFICATION_HEADER = "umb-notifications";

package/dist-cms/packages/core/resources/isUmbNotifications.function.js

@@ -1,8 +1,4 @@
 import { EventMessageTypeModel } from '../backend-api/index.js';
-/**
- *
- * @param notification
- */
 function objectIsUmbNotification(notification) {
     if (typeof notification !== 'object' || notification === null) {
         return false;
@@ -14,8 +10,9 @@ function objectIsUmbNotification(notification) {
         Object.values(EventMessageTypeModel).includes(object.type));
 }
 /**
- *
- * @param notifications
+ * Checks if an array of unknown values are all valid UmbNotificationsEventModel objects.
+ * @param {Array<unknown>} notifications The array to check.
+ * @returns {boolean} True if all items are valid UmbNotificationsEventModel objects.
  */
 export function isUmbNotifications(notifications) {
     return notifications.every(objectIsUmbNotification);

package/dist-cms/packages/core/resources/try-execute/try-execute.controller.js

@@ -7,6 +7,13 @@ import { UmbCancelError } from '../umb-error.js';
  * The UI should handle these cases without showing a notification.
  */
 const IGNORED_ERROR_CODES = [401, 403, 404];
+/**
+ * Operation statuses that are ignored for notifications.
+ * These are operation statuses where the server already sends a notification
+ * via the Umb-Notifications response header, so we avoid showing a duplicate
+ * notification from the ProblemDetails body.
+ */
+const IGNORED_OPERATION_STATUSES = ['CancelledByNotification'];
 export class UmbTryExecuteController extends UmbResourceController {
     #abortSignal;
     async tryExecute(opts) {
@@ -50,6 +57,12 @@ export class UmbTryExecuteController extends UmbResourceController {
                 // so we avoid showing a notification
                 return;
             }
+            if (apiError.problemDetails.operationStatus &&
+                IGNORED_OPERATION_STATUSES.includes(apiError.problemDetails.operationStatus)) {
+                // These operation statuses are already handled by the Umb-Notifications header interceptor
+                // so we avoid showing a duplicate notification
+                return;
+            }
             // UmbProblemDetails, show notification
             message = apiError.problemDetails.title;
             details = apiError.problemDetails.errors ?? undefined;

package/dist-cms/packages/core/resources/try-execute/tryXhrRequest.function.js

@@ -17,7 +17,7 @@ export async function tryXhrRequest(host, options) {
     const promise = createXhrRequest({
         ...options,
         baseUrl: config.baseUrl,
-        token: () => (typeof config.auth === 'function' ? config.auth({ type: 'http', scheme: 'bearer' }) : config.auth),
+        token: '[redacted]',
     });
     const controller = new UmbTryExecuteController(host, promise);
     const response = await controller.tryExecute(options);

package/dist-cms/packages/core/router/conditions/is-routable-context/constants.d.ts

@@ -0,0 +1 @@
+export declare const UMB_IS_ROUTABLE_CONTEXT_CONDITION_ALIAS = "Umb.Condition.IsRoutableContext";

package/dist-cms/packages/core/router/conditions/is-routable-context/constants.js

@@ -0,0 +1 @@
+export const UMB_IS_ROUTABLE_CONTEXT_CONDITION_ALIAS = 'Umb.Condition.IsRoutableContext';

package/dist-cms/packages/core/router/conditions/is-routable-context/index.d.ts

@@ -0,0 +1,2 @@
+export { UmbIsRoutableContextCondition } from './is-routable-context.condition.js';
+export * from './constants.js';

package/dist-cms/packages/core/router/conditions/is-routable-context/index.js

@@ -0,0 +1,2 @@
+export { UmbIsRoutableContextCondition } from './is-routable-context.condition.js';
+export * from './constants.js';

package/dist-cms/packages/core/router/conditions/is-routable-context/is-routable-context.condition.d.ts

@@ -0,0 +1,7 @@
+import type { UmbIsRoutableContextConditionConfig } from './types.js';
+import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from '../../../../../libs/extension-api/index.js';
+import { UmbConditionBase } from '../../../extension-registry/index.js';
+export declare class UmbIsRoutableContextCondition extends UmbConditionBase<UmbIsRoutableContextConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UmbIsRoutableContextConditionConfig>);
+}

package/dist-cms/packages/core/router/conditions/is-routable-context/is-routable-context.condition.js

@@ -0,0 +1,18 @@
+import { UMB_ROUTE_CONTEXT } from '../../route/route.context.js';
+import { UmbConditionBase } from '../../../extension-registry/index.js';
+export class UmbIsRoutableContextCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        // Default match value is true (checking if we are in a routable context)
+        const matchValue = this.config.match ?? true;
+        // Default state: we assume we are NOT in a routable context.
+        // So if match is false (looking for "not in routable context"), we start as permitted.
+        // If match is true (looking for "in routable context"), we start as not permitted.
+        this.permitted = !matchValue;
+        this.consumeContext(UMB_ROUTE_CONTEXT, () => {
+            // Route context found, so we ARE in a routable context.
+            // Permitted if match is true, not permitted if match is false.
+            this.permitted = matchValue;
+        });
+    }
+}