@umbraco-cms/backoffice 16.0.0-rc → 16.0.0-rc3

package/dist-cms/packages/core/sorter/sorter.controller.js

@@ -5,8 +5,9 @@ const autoScrollSensitivity = 50;
 const autoScrollSpeed = 16;
 /**
  *
- * @param el
- * @param includeSelf
+ * @param {Element} el - The element to check for ability to scroll
+ * @param {Boolean} includeSelf - If true, the element itself will be included in the check
+ * @returns {Element | null}
  */
 function getParentScrollElement(el, includeSelf) {
     if (!el || !el.getBoundingClientRect)
@@ -40,8 +41,8 @@ function getParentScrollElement(el, includeSelf) {
 }
 /**
  *
- * @param element
- * @param ignorerSelectors
+ * @param {HTMLElement} element - The element to check
+ * @param {string} ignorerSelectors - A comma separated list of selectors to ignore
  */
 function setupIgnorerElements(element, ignorerSelectors) {
     const selectors = ignorerSelectors.split(',');
@@ -52,8 +53,8 @@ function setupIgnorerElements(element, ignorerSelectors) {
 }
 /**
  *
- * @param element
- * @param ignorerSelectors
+ * @param {HTMLElement} element - The element to check
+ * @param {string} ignorerSelectors - A comma separated list of selectors to ignore
  */
 function destroyIgnorerElements(element, ignorerSelectors) {
     const selectors = ignorerSelectors.split(',');
@@ -64,7 +65,7 @@ function destroyIgnorerElements(element, ignorerSelectors) {
 }
 /**
  *
- * @param element
+ * @param {Element} element - The element to check
  */
 function setupPreventEvent(element) {
     element.draggable = false;
@@ -72,7 +73,7 @@ function setupPreventEvent(element) {
 }
 /**
  *
- * @param element
+ * @param {Element} element - The element to check
  */
 function destroyPreventEvent(element) {
     element.draggable = false;
@@ -130,9 +131,23 @@ export class UmbSorterController extends UmbControllerBase {
         this.#initialize = () => {
             if (this.#isConnected === false)
                 return;
-            const containerEl = (this.#config.containerSelector
+            if (this.#containerElement) {
+                // This can happen, so no need to show an error as it seems to be happening in some cases. We will just reject. [NL]
+                //console.error('Container element already initialized', this.#containerElement);
+                return;
+            }
+            const containerEl = this.#config.containerSelector
                 ? this.#host.shadowRoot.querySelector(this.#config.containerSelector)
-                : this.#host) ?? this.#host;
+                : this.#host;
+            if (!containerEl) {
+                if (this.#config.containerSelector) {
+                    throw new Error(`Sorter could not find the container element, using this query selector '${this.#config.containerSelector}'.`);
+                }
+                else {
+                    throw new Error('Sorter could not get its host element.');
+                }
+                return;
+            }
             this.#containerElement = containerEl;
             this.#useContainerShadowRoot = this.#containerElement === this.#host;
             // Only look at the shadowRoot if the containerElement is host.
@@ -140,6 +155,7 @@ export class UmbSorterController extends UmbControllerBase {
                 ? (this.#containerElement.shadowRoot ?? this.#containerElement)
                 : this.#containerElement;
             containerElement.addEventListener('dragover', this.#itemDraggedOver);
+            containerElement.addEventListener('drop', this.#itemDropped);
             this.#observer.disconnect();
             containerElement.querySelectorAll(this.#config.itemSelector).forEach((child) => {
                 if (child.matches && child.matches(this.#config.itemSelector)) {
@@ -151,8 +167,8 @@ export class UmbSorterController extends UmbControllerBase {
                 subtree: false,
             });
         };
-        this.#itemDraggedOver = (e) => {
-            //if(UmbSorterController.activeSorter === this) return;
+        this.#itemDraggedOver = async (e) => {
+            const newDrop = await this.#obtainIncomingItem(e);
             const dropSorter = _a.dropSorter;
             if (!dropSorter || dropSorter.identifier !== this.identifier)
                 return;
@@ -162,7 +178,7 @@ export class UmbSorterController extends UmbControllerBase {
                     e.dataTransfer.dropEffect = 'move';
                 }
                 // Do nothing as we are the active sorter.
-                this.#handleDragMove(e);
+                this.#handleDragMove(e, newDrop);
                 // Maybe we need to stop the event in this case.
                 // Do not bubble up to parent sorters:
                 e.stopPropagation();
@@ -179,6 +195,10 @@ export class UmbSorterController extends UmbControllerBase {
                 e.stopPropagation();
             }
         };
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.#itemDropped = async (_e) => {
+            this.#handleMoveEnd();
+        };
         this.#handleHandleMouseDown = (event) => {
             const target = event.target;
             const composedPath = event.composedPath();
@@ -224,31 +244,36 @@ export class UmbSorterController extends UmbControllerBase {
                 console.error('drag start ws cancelled due to another drag was still active');
                 this.#handleDragEnd();
             }
-            event.stopPropagation();
-            if (event.dataTransfer) {
-                const dragElement = _a.activeDragElement ?? element;
-                const activeDragRect = dragElement.getBoundingClientRect();
-                event.dataTransfer.setDragImage(dragElement, event.clientX - activeDragRect.x, event.clientY - activeDragRect.y);
-                event.dataTransfer.dropEffect = 'move';
-                event.dataTransfer.effectAllowed = 'all'; // copyMove when we enhance the drag with clipboard data.// defaults to 'all'
-            }
             if (!this.#scrollElement) {
                 this.#scrollElement = getParentScrollElement(this.#containerElement, true);
             }
+            const containerRect = this.#containerElement.getBoundingClientRect();
+            this.#containerElement.style.minHeight = containerRect.height + 'px';
             this.#setCurrentElement(element);
-            _a.activeDragElement?.addEventListener('dragend', this.#handleDragEnd);
+            //UmbSorterController.activeDragElement?.addEventListener('dragend', this.#handleDragEnd);
             window.addEventListener('mouseup', this.#handleMouseUp);
             window.addEventListener('mouseout', this.#handleMouseUp);
             window.addEventListener('mouseleave', this.#handleMouseUp);
             window.addEventListener('mousemove', this.#handleMouseMove);
             _a.activeItem = this.getItemOfElement(_a.activeElement);
-            _a.originalSorter = this;
-            // Notice, it is acceptable here to get index via object reference, but only cause there has been no change at this stage, otherwise we cannot trust the object instance is represented in the model — it could have mutated or been cloned [NL]
-            _a.originalIndex = this.#model.indexOf(_a.activeItem);
             if (!_a.activeItem) {
                 console.error('Could not find item related to this element.', _a.activeElement);
                 return;
             }
+            const activeUnique = this.#config.getUniqueOfModel(_a.activeItem);
+            event.stopPropagation();
+            if (event.dataTransfer) {
+                const dragElement = _a.activeDragElement ?? element;
+                const activeDragRect = dragElement.getBoundingClientRect();
+                event.dataTransfer.setDragImage(dragElement, event.clientX - activeDragRect.x, event.clientY - activeDragRect.y);
+                event.dataTransfer.dropEffect = 'move';
+                event.dataTransfer.effectAllowed = 'all'; // copyMove when we enhance the drag with clipboard data.// defaults to 'all'
+                event.dataTransfer.setData('text/umb-sorter-identifier#' + this.identifier.toString(), 'true');
+                event.dataTransfer.setData('text/umb-sorter-item-unique#' + activeUnique?.toString(), 'true');
+            }
+            _a.originalSorter = this;
+            // Notice, it is acceptable here to get index via object reference, but only cause there has been no change at this stage, otherwise we cannot trust the object instance is represented in the model — it could have mutated or been cloned [NL]
+            _a.originalIndex = this.#model.findIndex((x) => this.#config.getUniqueOfModel(x) === activeUnique);
             // Get the current index of the item:
             _a.activeIndex = _a.originalIndex;
             _a.activeDragElement.style.transform = 'translateZ(0)'; // Solves problem with FireFox and ShadowDom in the drag-image.
@@ -281,6 +306,10 @@ export class UmbSorterController extends UmbControllerBase {
                 // Revert move, to start position.
                 _a.originalSorter.moveItemInModel(_a.originalIndex ?? 0, _a.activeSorter);
             }
+            else if (_a.originalSorter === undefined) {
+                // The external dropped item, should be reverted back to where it came from.
+                // TODO: Revert back to original position.
+            }
             this.#handleMoveEnd();
         };
         /**
@@ -299,14 +328,14 @@ export class UmbSorterController extends UmbControllerBase {
         };
         this.#updateDragMove = () => {
             _a.rqaId = undefined;
-            if (!_a.activeElement || !_a.activeItem) {
+            if (!_a.activeItem) {
                 return;
             }
             if (_a.dropSorter !== this) {
                 throw new Error('Drop sorter is not this sorter');
             }
             // Maybe no need to check this twice, like we do it before the RAF an inside it, I think its fine to choose one of them.
-            const currentElementRect = _a.activeElement.getBoundingClientRect();
+            const currentElementRect = _a.activeElement?.getBoundingClientRect() ?? new DOMRect(0, 0, 0, 0);
             const insideCurrentRect = isWithinRect(this.#dragX, this.#dragY, currentElementRect);
             if (insideCurrentRect) {
                 return;
@@ -354,7 +383,8 @@ export class UmbSorterController extends UmbControllerBase {
                     placeAfter = this.#dragX > centerX;
                 }
             });
-            let activeIndex = this.#model.indexOf(_a.activeItem);
+            const activeUnique = this.#config.getUniqueOfModel(_a.activeItem);
+            let activeIndex = this.#model.findIndex((x) => this.#config.getUniqueOfModel(x) === activeUnique);
             if (activeIndex === -1) {
                 activeIndex = null;
             }
@@ -531,7 +561,7 @@ export class UmbSorterController extends UmbControllerBase {
             return;
         this.#enabled = true;
         if (this.#isConnected) {
-            this.#initialize();
+            requestAnimationFrame(this.#initialize);
         }
     }
     /**
@@ -552,7 +582,7 @@ export class UmbSorterController extends UmbControllerBase {
     }
     /**
      * Returns the model of the sorter.
-     * @returns {Array<T>}
+     * @returns {Array<T>} The model of this sorter.
      * @memberof UmbSorterController
      */
     getModel() {
@@ -565,6 +595,8 @@ export class UmbSorterController extends UmbControllerBase {
         return this.#model.find((x) => this.#config.getUniqueOfModel(x) === unique);
     }
     hostConnected() {
+        if (this.#isConnected)
+            return;
         this.#isConnected = true;
         if (this.#enabled) {
             requestAnimationFrame(this.#initialize);
@@ -578,19 +610,84 @@ export class UmbSorterController extends UmbControllerBase {
     }
     #initialize;
     #uninitialize() {
-        // TODO: Is there more clean up to do??
+        // Do something when host element is disconnected.
+        if (_a.activeSorter === this) {
+            _a.activeSorter = undefined;
+            if (_a.activeElement) {
+                this.#handleDragEnd();
+            }
+        }
+        if (_a.dropSorter === this) {
+            // If we are the drop sorter, we can now remove out self to get into pure Native Drag n' drop.
+            _a.dropSorter = undefined;
+        }
+        if (_a.lastIndicationSorter === this) {
+            // If we are the lastIndicationSorter, we can now remove out self to get into pure Native Drag n' drop.
+            _a.lastIndicationSorter = undefined;
+        }
         this.#observer.disconnect();
+        // For auto scroller:
+        this.#scrollElement = null;
         if (this.#containerElement) {
             // Only look at the shadowRoot if the containerElement is host.
             const containerElement = this.#useContainerShadowRoot
                 ? (this.#containerElement.shadowRoot ?? this.#containerElement)
                 : this.#containerElement;
             containerElement.removeEventListener('dragover', this.#itemDraggedOver);
+            containerElement.removeEventListener('drop', this.#itemDropped);
             this.#containerElement = undefined;
         }
         this.#elements.forEach((item) => this.destroyItem(item));
     }
+    async #obtainIncomingItem(e) {
+        if (!_a.dropSorter &&
+            e.dataTransfer?.types.includes('text/umb-sorter-identifier#' + this.identifier.toString())) {
+            // If we have no drop-sorter, and we share the same identifier, then we like to accept this drag.
+            const activeType = e.dataTransfer?.types.find((x) => x.startsWith('text/umb-sorter-item-unique#'));
+            if (activeType) {
+                const activeUnique = activeType.split('#')?.[1];
+                let activeItem = this.#model.find((x) => this.#config.getUniqueOfModel(x) === activeUnique);
+                if (activeItem) {
+                    _a.activeSorter = this;
+                }
+                // test if unique is already in the model:
+                if (!activeItem) {
+                    // Find the active item:
+                    activeItem = await this.#config.onRequestDrop?.({ unique: activeUnique });
+                    _a.activeSorter = undefined; // Important as we use this to know if we can remove the item via these Sorter references or if it is a Native Drop.
+                    if (!activeItem) {
+                        // Then we assume this item was not part of this sorters scope. This is the spot where inserting a new item from dataTransfer could be implemented.
+                        return false;
+                    }
+                }
+                if (this.hasItem(activeUnique)) {
+                    return false;
+                }
+                e.dataTransfer.setData('text/umb-sorter-item-accepted', 'true');
+                // Set states:
+                _a.activeItem = activeItem;
+                _a.activeElement = undefined;
+                _a.activeDragElement = undefined;
+                _a.dropSorter = this;
+                _a.originalIndex = undefined;
+                _a.originalSorter = undefined;
+                //UmbSorterController.activeSorter = this as unknown as UmbSorterController<unknown>;
+                //UmbSorterController.originalSorter = this as unknown as UmbSorterController<unknown>;
+                window.addEventListener('mouseup', this.#handleMouseUp);
+                window.addEventListener('mouseout', this.#handleMouseUp);
+                window.addEventListener('mouseleave', this.#handleMouseUp);
+                window.addEventListener('mousemove', this.#handleMouseMove);
+                if (!this.#scrollElement) {
+                    this.#scrollElement = getParentScrollElement(this.#containerElement, true);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
     #itemDraggedOver;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #itemDropped;
     #getDraggableElement(element) {
         if (this.#config.draggableSelector) {
             // Concept for enabling getting element within ShadowRoot: (But it might need to be configurable, so its still possible to get light dom element(slotted), despite the host is a web-component with shadow-dom.) [NL]
@@ -628,6 +725,10 @@ export class UmbSorterController extends UmbControllerBase {
         return element;
     }
     setupItem(element) {
+        if (this.#elements.includes(element)) {
+            console.error('Element already setup', element);
+            return;
+        }
         if (this.#config.ignorerSelector) {
             setupIgnorerElements(element, this.#config.ignorerSelector);
         }
@@ -690,6 +791,7 @@ export class UmbSorterController extends UmbControllerBase {
                 this.#config.draggableSelector +
                 '"');
         }
+        //UmbSorterController.activeDragElement?.addEventListener('dragend', this.#handleDragEnd);
         this.#setupPlaceholderStyle();
     }
     #handleHandleMouseDown;
@@ -704,28 +806,24 @@ export class UmbSorterController extends UmbControllerBase {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     #handleMouseUp;
     #handleMoveEnd() {
-        if (!_a.activeElement || !_a.activeItem) {
-            return;
+        this.#cleanupMove();
+        this.#stopAutoScroll();
+        this.removeAllowIndication();
+        if (_a.activeElement && _a.activeItem) {
+            const element = _a.activeElement;
+            if (this.#config.onEnd) {
+                this.#config.onEnd({
+                    item: _a.activeItem,
+                    element: element,
+                });
+            }
         }
-        const element = _a.activeElement;
         if (_a.activeDragElement) {
             _a.activeDragElement.style.transform = '';
             _a.activeDragElement.draggable = false;
             _a.activeDragElement.removeEventListener('dragend', this.#handleDragEnd);
         }
-        window.removeEventListener('mouseup', this.#handleMouseUp);
-        window.removeEventListener('mouseout', this.#handleMouseUp);
-        window.removeEventListener('mouseleave', this.#handleMouseUp);
-        window.removeEventListener('mousemove', this.#handleMouseMove);
         this.#removePlaceholderStyle();
-        this.#stopAutoScroll();
-        this.removeAllowIndication();
-        if (this.#config.onEnd) {
-            this.#config.onEnd({
-                item: _a.activeItem,
-                element: element,
-            });
-        }
         if (_a.rqaId) {
             cancelAnimationFrame(_a.rqaId);
             _a.rqaId = undefined;
@@ -740,8 +838,17 @@ export class UmbSorterController extends UmbControllerBase {
         this.#dragX = 0;
         this.#dragY = 0;
     }
-    #handleDragMove(event) {
-        if (!_a.activeElement) {
+    #cleanupMove() {
+        if (this.#containerElement) {
+            this.#containerElement.style.minHeight = '';
+        }
+        window.removeEventListener('mouseup', this.#handleMouseUp);
+        window.removeEventListener('mouseout', this.#handleMouseUp);
+        window.removeEventListener('mouseleave', this.#handleMouseUp);
+        window.removeEventListener('mousemove', this.#handleMouseMove);
+    }
+    #handleDragMove(event, instant) {
+        if (!_a.activeItem) {
             return;
         }
         const clientX = event.touches
@@ -757,8 +864,12 @@ export class UmbSorterController extends UmbControllerBase {
             this.#dragX = clientX;
             this.#dragY = clientY;
             this.handleAutoScroll(this.#dragX, this.#dragY);
-            const activeDragRect = _a.activeDragElement.getBoundingClientRect();
-            const insideCurrentRect = isWithinRect(this.#dragX, this.#dragY, activeDragRect);
+            if (instant) {
+                this.#updateDragMove();
+                return;
+            }
+            const activeDragRect = _a.activeDragElement?.getBoundingClientRect();
+            const insideCurrentRect = activeDragRect ? isWithinRect(this.#dragX, this.#dragY, activeDragRect) : false;
             if (!insideCurrentRect) {
                 if (_a.rqaId === undefined) {
                     _a.rqaId = requestAnimationFrame(this.#updateDragMove);
@@ -798,8 +909,9 @@ export class UmbSorterController extends UmbControllerBase {
         return null;
     }
     //
+    // TODO: Should rename to move item to.. [NL]
     async #moveElementTo(newIndex) {
-        if (!_a.activeElement || !_a.activeSorter) {
+        if (!_a.activeItem) {
             return;
         }
         const requestingSorter = _a.dropSorter;
@@ -843,10 +955,9 @@ export class UmbSorterController extends UmbControllerBase {
             return (await this.#config.performItemRemove({ item })) ?? false;
         }
         else {
-            const oldIndex = this.#model.indexOf(item);
-            if (oldIndex !== -1) {
-                const newModel = [...this.#model];
-                newModel.splice(oldIndex, 1);
+            const itemUnique = this.#config.getUniqueOfModel(item);
+            const newModel = this.#model.filter((x) => this.#config.getUniqueOfModel(x) !== itemUnique);
+            if (this.#model.length !== newModel.length) {
                 this.#model = newModel;
                 this.#config.onChange?.({ model: newModel, item });
                 return true;
@@ -867,29 +978,73 @@ export class UmbSorterController extends UmbControllerBase {
             console.error('Failed to retrieve active item unique');
             return false;
         }
-        // We use the getItem method to find the current item/object of this entry, as we cannot trust the object instance(activeItem) to be the same as in the model. [NL]
-        // So notice, item in this method is the real modal entry reference, where in many other cases we use the activeItem which might not be up to date with the real entry of the model. [NL]
-        const item = fromCtrl.getItem(itemUnique);
-        if (!item) {
-            console.error('Could not find item of model to move', itemUnique, this.#model);
-            return false;
+        let item;
+        if (fromCtrl) {
+            // If we got a fromCtrl, we should use it to get the item, to verify that it holds the model.
+            // We use the getItem method to find the current item/object of this entry, as we cannot trust the object instance(activeItem) to be the same as in the model. [NL]
+            // So notice, item in this method is the real modal entry reference, where in many other cases we use the activeItem which might not be up to date with the real entry of the model. [NL]
+            const foundTheItem = fromCtrl.getItem(itemUnique);
+            if (!foundTheItem) {
+                console.error('Could not find item of model to move', itemUnique, this.#model);
+                return false;
+            }
+            item = foundTheItem;
         }
-        if (this.notifyRequestDrop({ item }) === false) {
+        else {
+            item = _a.activeItem; //this.#model.find((x) => this.#config.getUniqueOfModel(x) === itemUnique) as T | undefined;
+            if (!item) {
+                return false;
+            }
+        }
+        // If we do not have a formCtrl, then it means that we dont know where it comes from, like via native drag across the Sorters awareness.
+        if (this.notifyRequestMove({ item }) === false) {
             return false;
         }
-        const localMove = fromCtrl === this;
+        let localMove = fromCtrl === this;
         if (!localMove) {
             // Not a local move, so we have to switch container to continue:
-            if ((await fromCtrl.removeItem(item)) !== true) {
-                console.error('Sync could not remove item when moving to a new container');
-                return false;
+            // Notice if fromCtrl is not defined this is properly a native drop.
+            if (fromCtrl) {
+                if ((await fromCtrl.removeItem(item)) !== true) {
+                    console.error('Sorter could not remove item before moving to a new container');
+                    return false;
+                }
+            }
+            else if (!fromCtrl) {
+                // Before we react to the external factor, lets see if we already got it in our model.
+                // Remove from the external model.
+                if (!this.#config.requestExternalRemove) {
+                    console.error('Sorter needs the requestExternalRemove to be defined, therefor we cannot drop the external item');
+                    return false;
+                }
+                _a.activeSorter = this;
+                fromCtrl = this;
+                if ((await this.#config.requestExternalRemove({ item })) !== true) {
+                    console.error('Sorter could not remove the item before moving to a new container');
+                    return false;
+                }
+                if ((await this.#config.requestExternalInsert?.({ item })) !== true) {
+                    console.error('Sorter could not insert the item into the new container');
+                    return false;
+                }
+                // This requestExternalInsert ^^ could have updated the model already. if so we should skip ahead to just move the item as a local move.
+                if (this.#model.find((x) => this.#config.getUniqueOfModel(x) === itemUnique)) {
+                    localMove = true;
+                }
             }
+        }
+        if (!localMove) {
             if (this.#config.performItemInsert) {
                 const result = await this.#config.performItemInsert({ item, newIndex });
                 if (result === false) {
                     console.error('Sync could not insert after a move a new container');
                     return false;
                 }
+                // If everything went well, we can set the new activeSorter (and dropSorter) to this, as we are switching container. [NL]
+                _a.activeSorter = this;
+                _a.dropSorter = this;
+                _a.activeIndex =
+                    this.#model.findIndex((x) => this.#config.getUniqueOfModel(x) === itemUnique) ?? 0;
             }
             else {
                 const newModel = [...this.#model];
@@ -910,7 +1065,7 @@ export class UmbSorterController extends UmbControllerBase {
         }
         if (localMove) {
             // Local move:
-            const oldIndex = this.#model.indexOf(item);
+            const oldIndex = this.#model.findIndex((x) => this.#config.getUniqueOfModel(x) === itemUnique);
             if (oldIndex === -1) {
                 console.error('Could not find item in model when performing internal move', this.getHostElement(), this.#model);
                 return false;
@@ -941,7 +1096,7 @@ export class UmbSorterController extends UmbControllerBase {
             _a.lastIndicationSorter.notifyAllowed();
         }
         _a.lastIndicationSorter = this;
-        if (this.notifyRequestDrop({ item: item }) === true) {
+        if (this.notifyRequestMove({ item: item }) === true) {
             this.notifyAllowed();
             return true;
         }
@@ -1019,23 +1174,11 @@ export class UmbSorterController extends UmbControllerBase {
             });
         }
     }
-    notifyRequestDrop(data) {
+    notifyRequestMove(data) {
         if (this.#config.onRequestMove) {
             return this.#config.onRequestMove(data) || false;
         }
         return true;
     }
-    destroy() {
-        super.destroy();
-        // Do something when host element is destroyed.
-        if (_a.activeElement) {
-            this.#handleDragEnd();
-        }
-        _a.lastIndicationSorter = undefined;
-        // TODO: Clean up items??
-        this.#observer.disconnect();
-        // For auto scroller:
-        this.#scrollElement = null;
-    }
 }
 _a = UmbSorterController;

package/dist-cms/packages/core/temporary-file/config/config.repository.d.ts

@@ -10,6 +10,7 @@ export declare class UmbTemporaryFileConfigRepository extends UmbRepositoryBase
      */
     initialized: Promise<void>;
     constructor(host: UmbControllerHost);
+    requestTemporaryFileConfiguration(): Promise<import("../../backend-api/types.gen.js").TemporaryFileConfigurationResponseModel>;
     /**
      * Subscribe to the entire configuration.
      */

package/dist-cms/packages/core/temporary-file/config/config.repository.js

@@ -22,11 +22,15 @@ export class UmbTemporaryFileConfigRepository extends UmbRepositoryBase {
         if (this.#dataStore?.getState()) {
             return;
         }
-        const { data } = await this.#dataSource.getConfig();
-        if (data) {
-            this.#dataStore?.update(data);
+        const temporaryFileConfig = await this.requestTemporaryFileConfiguration();
+        if (temporaryFileConfig) {
+            this.#dataStore?.update(temporaryFileConfig);
         }
     }
+    async requestTemporaryFileConfiguration() {
+        const { data } = await this.#dataSource.getConfig();
+        return data;
+    }
     /**
      * Subscribe to the entire configuration.
      */

package/dist-cms/packages/core/temporary-file/config/config.server.data-source.js

@@ -9,6 +9,6 @@ export class UmbTemporaryFileConfigServerDataSource {
      * Get the temporary file configuration.
      */
     getConfig() {
-        return tryExecute(this.#host, TemporaryFileService.getTemporaryFileConfiguration());
+        return tryExecute(this.#host, TemporaryFileService.getTemporaryFileConfiguration(), { disableNotifications: true });
     }
 }