@umbraco-cms/backoffice 17.2.1 → 17.3.0-rc

package/dist-cms/packages/media/media/modals/media-picker/components/media-picker-folder-path.element.js

@@ -7,9 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { UmbMediaDetailRepository } from '../../../repository/index.js';
 import { UmbMediaTreeRepository } from '../../../tree/index.js';
 import { UMB_MEDIA_ROOT_ENTITY_TYPE } from '../../../entity.js';
-import { css, html, customElement, state, repeat, property, } from '../../../../../../external/lit/index.js';
+import { css, html, customElement, nothing, state, repeat, property, } from '../../../../../../external/lit/index.js';
 import { UmbId } from '../../../../../core/id/index.js';
-import { getUmbracoFolderUnique } from '../../../../media-types/index.js';
+import { UmbMediaTypeStructureRepository } from '../../../../media-types/index.js';
 import { UmbLitElement } from '../../../../../core/lit-element/index.js';
 import { UmbChangeEvent } from '../../../../../core/event/index.js';
 const root = { name: 'Media', unique: null, entityType: UMB_MEDIA_ROOT_ENTITY_TYPE };
@@ -18,13 +18,20 @@ let UmbMediaPickerFolderPathElement = class UmbMediaPickerFolderPathElement exte
         super(...arguments);
         this.#mediaTreeRepository = new UmbMediaTreeRepository(this); // used to get file structure
         this.#mediaDetailRepository = new UmbMediaDetailRepository(this); // used to create folders
+        this.#mediaTypeStructureRepository = new UmbMediaTypeStructureRepository(this);
         this.startNode = root;
         this._currentMedia = root;
         this._paths = [root];
         this._typingNewFolder = false;
+        this._allowedFolderTypes = [];
+        this._selectingFolderType = false;
+        this.#selectedFolderType = null;
+        // Cache for all folder media types to avoid repeated API calls
+        this.#folderTypesPromise = null;
     }
     #mediaTreeRepository; // used to get file structure
     #mediaDetailRepository; // used to create folders
+    #mediaTypeStructureRepository;
     set currentMedia(value) {
         if (value !== this._currentMedia) {
             this._currentMedia = value;
@@ -34,6 +41,9 @@ let UmbMediaPickerFolderPathElement = class UmbMediaPickerFolderPathElement exte
     get currentMedia() {
         return this._currentMedia;
     }
+    #selectedFolderType;
+    // Cache for all folder media types to avoid repeated API calls
+    #folderTypesPromise;
     firstUpdated(_changedProperties) {
         super.firstUpdated(_changedProperties);
         this.#loadPath();
@@ -50,37 +60,74 @@ let UmbMediaPickerFolderPathElement = class UmbMediaPickerFolderPathElement exte
             name: item.name,
             unique: item.unique,
             entityType: item.entityType,
+            mediaType: { unique: item.mediaType.unique },
         }));
         if (!this.startNode) {
             paths.unshift(root);
         }
         this._paths = [...paths];
+        this.#updateAllowedFolderTypes();
+    }
+    async #getAllFolderTypes() {
+        if (!this.#folderTypesPromise) {
+            this.#folderTypesPromise = this.#mediaTypeStructureRepository.requestMediaTypesOfFolders();
+        }
+        return this.#folderTypesPromise;
+    }
+    async #updateAllowedFolderTypes() {
+        const currentPath = this._paths[this._paths.length - 1];
+        const mediaTypeUnique = currentPath?.mediaType?.unique ?? null;
+        const parentUnique = currentPath?.unique ?? null;
+        // Fetch allowed children of the current parent's media type
+        const { data: allowedChildrenData } = await this.#mediaTypeStructureRepository.requestAllowedChildrenOf(mediaTypeUnique, parentUnique);
+        const allowedChildren = allowedChildrenData?.items ?? [];
+        // Fetch all folder media types
+        const allFolderTypes = await this.#getAllFolderTypes();
+        // Intersect: only folder types that are allowed children of this parent
+        const allowedFolderTypeUniques = new Set(allowedChildren.map((c) => c.unique));
+        this._allowedFolderTypes = allFolderTypes.filter((ft) => allowedFolderTypeUniques.has(ft.unique));
     }
     #goToFolder(entity) {
         this._paths = [...this._paths].slice(0, this._paths.findIndex((path) => path.unique === entity.unique) + 1);
         this.currentMedia = entity;
         this.dispatchEvent(new UmbChangeEvent());
     }
-    #focusFolderInput() {
+    #focusFolderInput(folderType) {
+        if (folderType) {
+            this.#selectedFolderType = folderType;
+        }
+        this._selectingFolderType = false;
         this._typingNewFolder = true;
         requestAnimationFrame(() => {
             const element = this.getHostElement().shadowRoot.querySelector('#new-folder');
             element.focus();
-            element.select();
         });
     }
+    #onAddFolderClick() {
+        if (this._allowedFolderTypes.length === 1) {
+            this.#selectedFolderType = this._allowedFolderTypes[0];
+            this.#focusFolderInput();
+        }
+        else if (this._allowedFolderTypes.length > 1) {
+            this._selectingFolderType = true;
+        }
+    }
+    #cancelFolderTypeSelection() {
+        this._selectingFolderType = false;
+    }
     async #addFolder(e) {
         e.stopPropagation();
         const newName = e.target.value;
         this._typingNewFolder = false;
-        if (!newName)
+        if (!newName || !this.#selectedFolderType?.unique)
             return;
         const newUnique = UmbId.new();
         const parentUnique = this._paths[this._paths.length - 1].unique;
+        const folderTypeUnique = this.#selectedFolderType.unique;
         const preset = {
             unique: newUnique,
             mediaType: {
-                unique: getUmbracoFolderUnique(),
+                unique: folderTypeUnique,
                 collection: null,
             },
             variants: [
@@ -103,10 +150,19 @@ let UmbMediaPickerFolderPathElement = class UmbMediaPickerFolderPathElement exte
         const name = data.variants[0].name;
         const unique = data.unique;
         const entityType = data.entityType;
-        this._paths = [...this._paths, { name, unique, entityType }];
-        this.currentMedia = { name, unique, entityType };
+        const mediaType = { unique: folderTypeUnique };
+        this._paths = [...this._paths, { name, unique, entityType, mediaType }];
+        this.currentMedia = { name, unique, entityType, mediaType };
         this.dispatchEvent(new UmbChangeEvent());
     }
+    #onKeypress(e) {
+        if (e.key === 'Enter') {
+            requestAnimationFrame(() => {
+                const element = this.getHostElement().shadowRoot.querySelector('#new-folder');
+                element.blur();
+            });
+        }
+    }
     render() {
         return html `<div id="path">
 			${repeat(this._paths, (path) => path.unique, (path) => html `<uui-button
@@ -114,16 +170,39 @@ let UmbMediaPickerFolderPathElement = class UmbMediaPickerFolderPathElement exte
 							.label=${path.name}
 							?disabled=${this.currentMedia.unique === path.unique}
 							@click=${() => this.#goToFolder(path)}></uui-button
-						>/`)}${this._typingNewFolder
-            ? html `<uui-input
-						id="new-folder"
-						label="enter a name"
-						value="new folder name"
-						@blur=${this.#addFolder}
-						auto-width></uui-input>`
-            : html `<uui-button label="add folder" compact @click=${this.#focusFolderInput}>+</uui-button>`}
+						>/`)}${this.#renderFolderCreation()}
 		</div>`;
     }
+    #renderFolderCreation() {
+        if (this._typingNewFolder) {
+            return html `<uui-input
+				id="new-folder"
+				label=${this.localize.term('create_enterFolderName')}
+				placeholder=${this.localize.term('create_enterFolderName')}
+				@blur=${this.#addFolder}
+				@keypress=${this.#onKeypress}
+				auto-width></uui-input>`;
+        }
+        if (this._selectingFolderType) {
+            return html `<div id="folder-type-selection">
+				${repeat(this._allowedFolderTypes, (ft) => ft.unique, (ft) => html `<uui-button compact look="outline" .label=${ft.name} @click=${() => this.#focusFolderInput(ft)}>
+							${ft.icon ? html `<umb-icon name=${ft.icon}></umb-icon>` : nothing} ${ft.name}
+						</uui-button>`)}
+				<uui-button compact .label=${this.localize.term('general_cancel')} @click=${this.#cancelFolderTypeSelection}>
+					<uui-icon name="icon-wrong"></uui-icon>
+				</uui-button>
+			</div>`;
+        }
+        if (this._allowedFolderTypes.length === 0) {
+            return nothing;
+        }
+        return html `<uui-button
+			label=${this.localize.term('visuallyHiddenTexts_createNewFolder')}
+			compact
+			@click=${this.#onAddFolderClick}>
+			<uui-icon name="icon-add"></uui-icon>
+		</uui-button>`;
+    }
     static { this.styles = [
         css `
 			#path {
@@ -137,6 +216,29 @@ let UmbMediaPickerFolderPathElement = class UmbMediaPickerFolderPathElement exte
 			#path uui-input {
 				height: 100%;
 			}
+
+			#new-folder {
+				margin-left: var(--uui-size-2);
+			}
+
+			#path uui-button uui-icon {
+				--uui-icon-color: inherit;
+			}
+
+			#folder-type-selection {
+				display: flex;
+				align-items: center;
+				gap: var(--uui-size-2);
+				margin-left: var(--uui-size-2);
+			}
+
+			#folder-type-selection uui-button {
+				font-weight: normal;
+			}
+
+			#folder-type-selection umb-icon {
+				margin-right: var(--uui-size-1);
+			}
 		`,
     ]; }
 };
@@ -155,6 +257,12 @@ __decorate([
 __decorate([
     state()
 ], UmbMediaPickerFolderPathElement.prototype, "_typingNewFolder", void 0);
+__decorate([
+    state()
+], UmbMediaPickerFolderPathElement.prototype, "_allowedFolderTypes", void 0);
+__decorate([
+    state()
+], UmbMediaPickerFolderPathElement.prototype, "_selectingFolderType", void 0);
 UmbMediaPickerFolderPathElement = __decorate([
     customElement('umb-media-picker-folder-path')
 ], UmbMediaPickerFolderPathElement);

package/dist-cms/packages/media/media/modals/media-picker/media-picker-modal.element.js

@@ -11,7 +11,7 @@ import { UmbMediaSearchProvider } from '../../search/index.js';
 import { UmbMediaPickerContext } from './media-picker.context.js';
 import { css, customElement, html, ifDefined, nothing, query, repeat, state, } from '../../../../../external/lit/index.js';
 import { debounce, UmbPaginationManager } from '../../../../core/utils/index.js';
-import { isUmbracoFolder } from '../../../media-types/index.js';
+import { UmbMediaTypeStructureRepository } from '../../../media-types/index.js';
 import { UmbPickerModalBaseElement } from '../../../../core/picker/index.js';
 import { UMB_PROPERTY_TYPE_BASED_PROPERTY_CONTEXT } from '../../../../content/content/index.js';
 import { UMB_VARIANT_CONTEXT } from '../../../../core/variant/index.js';
@@ -24,6 +24,8 @@ let UmbMediaPickerModalElement = class UmbMediaPickerModalElement extends UmbPic
     #mediaTreeRepository;
     #mediaItemRepository;
     #mediaSearchProvider;
+    #mediaTypeStructureRepository;
+    #folderTypeUniques;
     #dataType;
     #pagingMap;
     #contextCulture;
@@ -33,6 +35,8 @@ let UmbMediaPickerModalElement = class UmbMediaPickerModalElement extends UmbPic
         this.#mediaTreeRepository = new UmbMediaTreeRepository(this);
         this.#mediaItemRepository = new UmbMediaItemRepository(this);
         this.#mediaSearchProvider = new UmbMediaSearchProvider(this);
+        this.#mediaTypeStructureRepository = new UmbMediaTypeStructureRepository(this);
+        this.#folderTypeUniques = new Set();
         /* TODO: We currently only rely on the interactionMemory manager in the picker interface which is correctly implemented in the Media Picker
         Remove this type cast when MediaPicker has implemented the full PickerContext interface */
         this._pickerContext = new UmbMediaPickerContext(this);
@@ -87,12 +91,18 @@ let UmbMediaPickerModalElement = class UmbMediaPickerModalElement extends UmbPic
                     name: source.name,
                     unique: source.unique,
                     entityType: source.entityType,
+                    mediaType: { unique: source.mediaType.unique },
                 };
                 this._searchFrom = { unique: source.unique, entityType: source.entityType };
             }
         }
+        await this.#loadFolderTypes();
         this.#loadChildrenOfCurrentMediaItem();
     }
+    async #loadFolderTypes() {
+        const folderTypes = await this.#mediaTypeStructureRepository.requestMediaTypesOfFolders();
+        this.#folderTypeUniques = new Set(folderTypes.map((ft) => ft.unique).filter((u) => u != null));
+    }
     // TODO: move to location manager in context
     async #loadChildrenOfCurrentMediaItem() {
         const key = this._currentMediaEntity.entityType + this._currentMediaEntity.unique;
@@ -163,6 +173,7 @@ let UmbMediaPickerModalElement = class UmbMediaPickerModalElement extends UmbPic
             name: item.name,
             unique: item.unique,
             entityType: item.entityType,
+            mediaType: { unique: item.mediaType.unique },
         };
         // If the user has navigated into an item, we default to search only within that item.
         this._searchFrom = this._currentMediaEntity.unique
@@ -256,7 +267,7 @@ let UmbMediaPickerModalElement = class UmbMediaPickerModalElement extends UmbPic
         this.#loadChildrenOfCurrentMediaItem();
     }
     #allowNavigateToMedia(item) {
-        return isUmbracoFolder(item.mediaType.unique) || item.hasChildren;
+        return this.#folderTypeUniques.has(item.mediaType.unique) || item.hasChildren;
     }
     // TODO: move to search manager in context
     #onSearchFromChange(e) {
@@ -379,6 +390,7 @@ let UmbMediaPickerModalElement = class UmbMediaPickerModalElement extends UmbPic
         return html `
 			<uui-card-media
 				class=${ifDefined(disabled ? 'not-allowed' : undefined)}
+				title=${item.name}
 				.name=${item.name}
 				data-mark="${item.entityType}:${item.unique}"
 				@open=${() => this.#onOpen(item)}

package/dist-cms/packages/media/media/modals/media-picker/types.d.ts

@@ -5,4 +5,7 @@ export interface UmbMediaCardItemModel extends UmbMediaItemModel {
 }
 export interface UmbMediaPathModel extends UmbEntityModel {
     name: string;
+    mediaType?: {
+        unique: string;
+    };
 }

package/dist-cms/packages/media/media/property-editors/media-entity-picker/property-editor-ui-media-entity-picker.element.js

@@ -4,6 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { UmbMediaPickerFolderFilter } from '../../components/input-media/input-media.context.js';
 import { UmbChangeEvent } from '../../../../core/event/index.js';
 import { html, customElement, property, state } from '../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../../core/lit-element/index.js';
@@ -37,6 +38,7 @@ let UmbPropertyEditorUIMediaEntityPickerElement = class UmbPropertyEditorUIMedia
 				.min=${this._min}
 				.max=${this._max}
 				.value=${this.value}
+				.folderFilter=${UmbMediaPickerFolderFilter.FOLDERS_ONLY}
 				?readonly=${this.readonly}
 				@change=${this.#onChange}></umb-input-media>
 		`;

package/dist-cms/packages/media/media/property-editors/media-picker/property-editor-ui-media-picker.element.d.ts

@@ -25,7 +25,7 @@ export declare class UmbPropertyEditorUIMediaPickerElement extends UmbPropertyEd
     private _startNode?;
     private _focalPointEnabled;
     private _preselectedCrops;
-    private _allowedMediaTypes;
+    private _allowedMediaTypes?;
     private _multiple;
     private _min;
     private _max;

package/dist-cms/packages/media/media/property-editors/media-picker/property-editor-ui-media-picker.element.js

@@ -20,7 +20,7 @@ let UmbPropertyEditorUIMediaPickerElement = class UmbPropertyEditorUIMediaPicker
         this.#interactionMemoryManager.setPropertyEditorConfig(config);
         if (!config)
             return;
-        this._allowedMediaTypes = config.getValueByAlias('filter')?.split(',') ?? [];
+        this._allowedMediaTypes = config.getValueByAlias('filter')?.split(',') ?? undefined;
         this._focalPointEnabled = Boolean(config.getValueByAlias('enableLocalFocalPoint'));
         this._multiple = Boolean(config.getValueByAlias('multiple'));
         this._preselectedCrops = config?.getValueByAlias('crops') ?? [];
@@ -43,7 +43,6 @@ let UmbPropertyEditorUIMediaPickerElement = class UmbPropertyEditorUIMediaPicker
         this.readonly = false;
         this._focalPointEnabled = false;
         this._preselectedCrops = [];
-        this._allowedMediaTypes = [];
         this._multiple = false;
         this._min = 0;
         this._max = Infinity;

package/dist-cms/packages/media/media/recycle-bin/entity-action/bulk-trash/manifests.js

@@ -10,6 +10,7 @@ const bulkTrashAction = {
     kind: UMB_ENTITY_BULK_ACTION_TRASH_WITH_RELATION_KIND,
     alias: 'Umb.EntityBulkAction.Media.Trash',
     name: 'Trash Media Entity Bulk Action',
+    api: () => import('./media-bulk-trash-with-relation.action.js'),
     weight: 10,
     forEntityTypes: [UMB_MEDIA_ENTITY_TYPE],
     meta: {

package/dist-cms/packages/media/media/recycle-bin/entity-action/bulk-trash/media-bulk-trash-with-relation.action.d.ts

@@ -0,0 +1,5 @@
+import { UmbBulkTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+export declare class UmbMediaBulkTrashWithRelationEntityAction extends UmbBulkTrashWithRelationEntityAction {
+    protected _confirmTrash(): Promise<void>;
+}
+export { UmbMediaBulkTrashWithRelationEntityAction as api };

package/dist-cms/packages/media/media/recycle-bin/entity-action/bulk-trash/media-bulk-trash-with-relation.action.js

@@ -0,0 +1,18 @@
+import { UMB_MEDIA_CONFIGURATION_CONTEXT } from '../../../global-contexts/index.js';
+import { UMB_BULK_TRASH_WITH_RELATION_CONFIRM_MODAL, UmbBulkTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+import { umbOpenModal } from '../../../../../core/modal/index.js';
+export class UmbMediaBulkTrashWithRelationEntityAction extends UmbBulkTrashWithRelationEntityAction {
+    async _confirmTrash() {
+        const configContext = await this.getContext(UMB_MEDIA_CONFIGURATION_CONTEXT);
+        const config = await configContext?.getMediaConfiguration();
+        await umbOpenModal(this, UMB_BULK_TRASH_WITH_RELATION_CONFIRM_MODAL, {
+            data: {
+                uniques: this.selection,
+                itemRepositoryAlias: this.args.meta.itemRepositoryAlias,
+                referenceRepositoryAlias: this.args.meta.referenceRepositoryAlias,
+                disableDeleteWhenReferenced: config?.disableDeleteWhenReferenced ?? false,
+            },
+        });
+    }
+}
+export { UmbMediaBulkTrashWithRelationEntityAction as api };

package/dist-cms/packages/media/media/recycle-bin/entity-action/manifests.js

@@ -10,6 +10,7 @@ export const manifests = [
         kind: 'trashWithRelation',
         alias: 'Umb.EntityAction.Media.RecycleBin.Trash',
         name: 'Trash Media Entity Action',
+        api: () => import('./trash/media-trash-with-relation.action.js'),
         forEntityTypes: [UMB_MEDIA_ENTITY_TYPE],
         meta: {
             itemRepositoryAlias: UMB_MEDIA_ITEM_REPOSITORY_ALIAS,

package/dist-cms/packages/media/media/recycle-bin/entity-action/trash/media-trash-with-relation.action.d.ts

@@ -0,0 +1,5 @@
+import { UmbTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+export declare class UmbMediaTrashWithRelationEntityAction extends UmbTrashWithRelationEntityAction {
+    protected _confirmTrash(item: any): Promise<void>;
+}
+export { UmbMediaTrashWithRelationEntityAction as api };

package/dist-cms/packages/media/media/recycle-bin/entity-action/trash/media-trash-with-relation.action.js

@@ -0,0 +1,19 @@
+import { UMB_MEDIA_CONFIGURATION_CONTEXT } from '../../../global-contexts/index.js';
+import { UMB_TRASH_WITH_RELATION_CONFIRM_MODAL, UmbTrashWithRelationEntityAction } from '../../../../../relations/relations/index.js';
+import { umbOpenModal } from '../../../../../core/modal/index.js';
+export class UmbMediaTrashWithRelationEntityAction extends UmbTrashWithRelationEntityAction {
+    async _confirmTrash(item) {
+        const configContext = await this.getContext(UMB_MEDIA_CONFIGURATION_CONTEXT);
+        const config = await configContext?.getMediaConfiguration();
+        await umbOpenModal(this, UMB_TRASH_WITH_RELATION_CONFIRM_MODAL, {
+            data: {
+                unique: item.unique,
+                entityType: item.entityType,
+                itemRepositoryAlias: this.args.meta.itemRepositoryAlias,
+                referenceRepositoryAlias: this.args.meta.referenceRepositoryAlias,
+                disableDeleteWhenReferenced: config?.disableDeleteWhenReferenced ?? false,
+            },
+        });
+    }
+}
+export { UmbMediaTrashWithRelationEntityAction as api };

package/dist-cms/packages/media/media/repository/detail/media-detail.repository.d.ts

@@ -4,6 +4,17 @@ import { UmbDetailRepositoryBase } from '../../../../core/repository/index.js';
 export declare class UmbMediaDetailRepository extends UmbDetailRepositoryBase<UmbMediaDetailModel> {
     #private;
     constructor(host: UmbControllerHost);
+    /**
+     * Creates a media item without showing automatic error notifications.
+     * Error handling is left to the caller (e.g. the dropzone manager).
+     */
+    createSilently(model: UmbMediaDetailModel, parentUnique: string | null): Promise<{
+        error: import("../../../../core/resources/index.js").UmbApiError | import("../../../../core/resources/index.js").UmbCancelError | undefined;
+        data?: undefined;
+    } | {
+        data: UmbMediaDetailModel;
+        error?: undefined;
+    }>;
     /**
      * @inheritdoc
      */

package/dist-cms/packages/media/media/repository/detail/media-detail.repository.js

@@ -7,6 +7,15 @@ export class UmbMediaDetailRepository extends UmbDetailRepositoryBase {
     constructor(host) {
         super(host, UmbMediaServerDataSource, UMB_MEDIA_DETAIL_STORE_CONTEXT);
     }
+    /**
+     * Creates a media item without showing automatic error notifications.
+     * Error handling is left to the caller (e.g. the dropzone manager).
+     */
+    async createSilently(model, parentUnique) {
+        if (!model)
+            throw new Error('Data is missing');
+        return this.detailDataSource.create(model, parentUnique, true);
+    }
     /**
      * @inheritdoc
      */

package/dist-cms/packages/media/media/repository/detail/media-detail.server.data-source.d.ts

@@ -37,7 +37,7 @@ export declare class UmbMediaServerDataSource extends UmbControllerBase implemen
      * @returns {*}
      * @memberof UmbMediaServerDataSource
      */
-    create(model: UmbMediaDetailModel, parentUnique?: string | null): Promise<{
+    create(model: UmbMediaDetailModel, parentUnique?: string | null, disableNotifications?: boolean): Promise<{
         error: import("../../../../core/resources/index.js").UmbApiError | import("../../../../core/resources/index.js").UmbCancelError | undefined;
         data?: undefined;
     } | {

package/dist-cms/packages/media/media/repository/detail/media-detail.server.data-source.js

@@ -99,7 +99,7 @@ export class UmbMediaServerDataSource extends UmbControllerBase {
      * @returns {*}
      * @memberof UmbMediaServerDataSource
      */
-    async create(model, parentUnique = null) {
+    async create(model, parentUnique = null, disableNotifications = false) {
         if (!model)
             throw new Error('Media is missing');
         if (!model.unique)
@@ -118,7 +118,7 @@ export class UmbMediaServerDataSource extends UmbControllerBase {
         };
         const { data, error } = await tryExecute(this, MediaService.postMedia({
             body,
-        }));
+        }), { disableNotifications });
         if (data && typeof data === 'string') {
             return this.read(data);
         }

package/dist-cms/packages/media/media/repository/item/media-item.server.data-source.js

@@ -44,5 +44,6 @@ const mapper = (item) => {
                 name: variant.name,
             };
         }),
+        flags: item.flags,
     };
 };

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

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

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

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

package/dist-cms/packages/media/media/repository/item/types.d.ts

@@ -1,7 +1,8 @@
 import type { UmbMediaEntityType } from '../../entity.js';
 import type { UmbEntityUnique } from '../../../../core/entity/index.js';
+import type { UmbEntityWithOptionalFlags } from '../../../../core/entity-flag/index.js';
 import type { UmbReferenceByUnique } from '../../../../core/models/index.js';
-export interface UmbMediaItemModel {
+export interface UmbMediaItemModel extends UmbEntityWithOptionalFlags {
     entityType: UmbMediaEntityType;
     hasChildren: boolean;
     isTrashed: boolean;

package/dist-cms/packages/media/media/search/global-search/manifests.js

@@ -12,6 +12,7 @@ export const manifests = [
         meta: {
             label: 'Media',
             searchProviderAlias: UMB_MEDIA_SEARCH_PROVIDER_ALIAS,
+            sectionAlias: UMB_MEDIA_SECTION_ALIAS,
         },
         conditions: [
             {

package/dist-cms/packages/media/media/search/media-search.server.data-source.js

@@ -31,6 +31,8 @@ export class UmbMediaSearchServerDataSource {
                 query: args.query,
                 trashed: args.includeTrashed,
                 dataTypeId: args.dataTypeUnique,
+                skip: args.paging?.skip,
+                take: args.paging?.take,
             },
         }));
         if (data) {
@@ -54,6 +56,7 @@ export class UmbMediaSearchServerDataSource {
                             name: variant.name,
                         };
                     }),
+                    flags: item.flags,
                 };
             });
             return { data: { items: mappedItems, total: data.total } };

package/dist-cms/packages/media/media/tree/server-data-source/media-tree.server.data-source.js

@@ -57,6 +57,7 @@ export class UmbMediaTreeServerDataSource extends UmbControllerBase {
                 };
             }),
             createDate: item.createDate,
+            flags: item.flags,
         };
     }
 }

package/dist-cms/packages/media/media/tree/tree-item/media-tree-item.context.js

@@ -1,13 +1,20 @@
 import { UmbDefaultTreeItemContext } from '../../../../core/tree/index.js';
 import { UmbIsTrashedEntityContext } from '../../../../core/recycle-bin/index.js';
+import { UmbEntityContentTypeEntityContext } from '../../../../content/content-type/index.js';
+import { UMB_MEDIA_TYPE_ENTITY_TYPE } from '../../../media-types/index.js';
 export class UmbMediaTreeItemContext extends UmbDefaultTreeItemContext {
     #isTrashedContext;
+    #entityContentTypeContext;
     constructor(host) {
         super(host);
         this.#isTrashedContext = new UmbIsTrashedEntityContext(this);
+        this.#entityContentTypeContext = new UmbEntityContentTypeEntityContext(this);
         this.noAccess = this._treeItem.asObservablePart((item) => item?.noAccess ?? false);
         this.observe(this.treeItem, (item) => {
             this.#isTrashedContext.setIsTrashed(item?.isTrashed || false);
+            const mediaTypeUnique = item?.mediaType.unique;
+            this.#entityContentTypeContext.setEntityType(mediaTypeUnique ? UMB_MEDIA_TYPE_ENTITY_TYPE : undefined);
+            this.#entityContentTypeContext.setUnique(mediaTypeUnique ?? undefined);
         });
     }
 }

package/dist-cms/packages/media/media/tree/tree-item/media-tree-item.element.d.ts

@@ -1,7 +1,6 @@
 import type { UmbMediaTreeItemModel } from '../types.js';
 import type { UmbMediaTreeItemContext } from './media-tree-item.context.js';
 import { UmbTreeItemElementBase } from '../../../../core/tree/index.js';
-declare const elementName = "umb-media-tree-item";
 export declare class UmbMediaTreeItemElement extends UmbTreeItemElementBase<UmbMediaTreeItemModel, UmbMediaTreeItemContext> {
     #private;
     set api(value: UmbMediaTreeItemContext | undefined);
@@ -12,6 +11,6 @@ export declare class UmbMediaTreeItemElement extends UmbTreeItemElementBase<UmbM
 export { UmbMediaTreeItemElement as element };
 declare global {
     interface HTMLElementTagNameMap {
-        [elementName]: UmbMediaTreeItemElement;
+        'umb-media-tree-item': UmbMediaTreeItemElement;
     }
 }