@umbraco-cms/backoffice 17.2.1 → 17.3.0-rc

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

@@ -4,9 +4,8 @@ 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 { css, html, customElement, nothing, classMap } from '../../../../../external/lit/index.js';
+import { css, html, customElement, nothing, classMap, when } from '../../../../../external/lit/index.js';
 import { UmbTreeItemElementBase } from '../../../../core/tree/index.js';
-const elementName = 'umb-media-tree-item';
 let UmbMediaTreeItemElement = class UmbMediaTreeItemElement extends UmbTreeItemElementBase {
     set api(value) {
         // Observe noAccess from context and update base class property (_noAccess).
@@ -15,16 +14,13 @@ let UmbMediaTreeItemElement = class UmbMediaTreeItemElement extends UmbTreeItemE
         super.api = value;
     }
     renderIconContainer() {
-        const icon = this.item?.mediaType.icon;
         return html `
-			<span id="icon-container" slot="icon">
-				${icon
-            ? html `
-							<umb-icon id="icon" slot="icon" name="${this._getIconToRender(icon)}"></umb-icon>
-							${this.#renderStateIcon()}
-						`
-            : nothing}
-			</span>
+			<div id="icon-container" slot="icon">
+				<umb-entity-sign-bundle .entityType=${this._item?.entityType} .entityFlags=${this._flags}>
+					${when(this.item?.mediaType.icon, (icon) => html `<umb-icon id="icon" name=${this._getIconToRender(icon)}></umb-icon>`)}
+				</umb-entity-sign-bundle>
+				${this.#renderStateIcon()}
+			</div>
 		`;
     }
     renderLabel() {
@@ -63,44 +59,17 @@ let UmbMediaTreeItemElement = class UmbMediaTreeItemElement extends UmbTreeItemE
 				bottom: -5px;
 				right: -5px;
 				font-size: 10px;
-				background: var(--uui-color-surface);
+				background: var(--umb-sign-bundle-bg, var(--uui-color-surface));
 				width: 14px;
 				height: 14px;
 				border-radius: 100%;
 				line-height: 14px;
 			}
-
-			:hover #state-icon {
-				background: var(--uui-color-surface-emphasis);
-			}
-
-			/** Active */
-			[active] #state-icon {
-				background: var(--uui-color-current);
-			}
-
-			[active]:hover #state-icon {
-				background: var(--uui-color-current-emphasis);
-			}
-
-			/** Selected */
-			[selected] #state-icon {
-				background-color: var(--uui-color-selected);
-			}
-
-			[selected]:hover #state-icon {
-				background-color: var(--uui-color-selected-emphasis);
-			}
-
-			/** Disabled */
-			[disabled] #state-icon {
-				background-color: var(--uui-color-disabled);
-			}
 		`,
     ]; }
 };
 UmbMediaTreeItemElement = __decorate([
-    customElement(elementName)
+    customElement('umb-media-tree-item')
 ], UmbMediaTreeItemElement);
 export { UmbMediaTreeItemElement };
 export { UmbMediaTreeItemElement as element };

package/dist-cms/packages/media/media/url/info-app/media-links-workspace-info-app.element.js

@@ -106,7 +106,7 @@ let UmbMediaLinksWorkspaceInfoAppElement = class UmbMediaLinksWorkspaceInfoAppEl
     #renderLinkItem(item) {
         if (!item.url)
             return nothing;
-        const ext = item.url.split(/[#?]/)[0].split('.').pop()?.trim();
+        const ext = item.url.split(/[#?]/)[0].split('.').pop()?.trim().toLowerCase();
         if (ext === 'svg') {
             return html `
 				<a href="#" target="_blank" class="link-item with-href" @click=${() => this.#openSvg(item.url)}>

package/dist-cms/packages/media/media/workspace/media-workspace.context.d.ts

@@ -3,7 +3,7 @@ import type { UmbMediaDetailModel, UmbMediaVariantModel } from '../types.js';
 import type { UmbMediaDetailRepository } from '../repository/index.js';
 import { UmbContentDetailWorkspaceContextBase, type UmbContentWorkspaceContext } from '../../../content/content/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
-import type { UmbMediaTypeDetailModel } from '../../media-types/index.js';
+import { type UmbMediaTypeDetailModel } from '../../media-types/index.js';
 import type { UmbVariantId } from '../../../core/variant/index.js';
 type ContentModel = UmbMediaDetailModel;
 type ContentTypeModel = UmbMediaTypeDetailModel;

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

@@ -9,9 +9,12 @@ import { UMB_MEDIA_WORKSPACE_ALIAS, UMB_MEMBER_DETAIL_MODEL_VARIANT_SCAFFOLD } f
 import { UmbContentDetailWorkspaceContextBase } from '../../../content/content/index.js';
 import { UmbEntityRestoredFromRecycleBinEvent, UmbEntityTrashedEvent, UmbIsTrashedEntityContext, } from '../../../core/recycle-bin/index.js';
 import { UmbWorkspaceIsNewRedirectController, UmbWorkspaceIsNewRedirectControllerAlias, } from '../../../core/workspace/index.js';
+import { UMB_MEDIA_TYPE_ENTITY_TYPE } from '../../media-types/index.js';
 import { UMB_ACTION_EVENT_CONTEXT } from '../../../core/action/index.js';
+import { UmbEntityContentTypeEntityContext } from '../../../content/content-type/index.js';
 export class UmbMediaWorkspaceContext extends UmbContentDetailWorkspaceContextBase {
     #isTrashedContext;
+    #entityContentTypeContext;
     #actionEventContext;
     constructor(host) {
         super(host, {
@@ -32,6 +35,7 @@ export class UmbMediaWorkspaceContext extends UmbContentDetailWorkspaceContextBa
         this.contentTypeHasCollection = this._data.createObservablePartOfCurrent((data) => !!data?.mediaType.collection);
         this.contentTypeIcon = this._data.createObservablePartOfCurrent((data) => data?.mediaType.icon);
         this.#isTrashedContext = new UmbIsTrashedEntityContext(this);
+        this.#entityContentTypeContext = new UmbEntityContentTypeEntityContext(this);
         this.#onRecycleBinEvent = (event) => {
             const unique = this.getUnique();
             const entityType = this.getEntityType();
@@ -40,6 +44,8 @@ export class UmbMediaWorkspaceContext extends UmbContentDetailWorkspaceContextBa
             this.reload();
         };
         this.observe(this.contentTypeUnique, (unique) => {
+            this.#entityContentTypeContext.setEntityType(unique ? UMB_MEDIA_TYPE_ENTITY_TYPE : undefined);
+            this.#entityContentTypeContext.setUnique(unique ?? undefined);
             if (unique) {
                 this.structure.loadType(unique);
             }

package/dist-cms/packages/media/media-types/entry-point.js

@@ -1,8 +1,12 @@
+import { UmbManagementApiMediaTypeDetailDataCacheInvalidationManager } from './repository/detail/server-data-source/media-type-detail.server.cache-invalidation.manager.js';
 import { UmbManagementApiMediaTypeItemDataCacheInvalidationManager } from './repository/item/media-type-item.server.cache-invalidation.manager.js';
+let detailDataCacheInvalidationManager;
 let itemDataCacheInvalidationManager;
 export const onInit = (host) => {
+    detailDataCacheInvalidationManager = new UmbManagementApiMediaTypeDetailDataCacheInvalidationManager(host);
     itemDataCacheInvalidationManager = new UmbManagementApiMediaTypeItemDataCacheInvalidationManager(host);
 };
 export const onUnload = () => {
+    detailDataCacheInvalidationManager?.destroy();
     itemDataCacheInvalidationManager?.destroy();
 };

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

@@ -1,7 +1,16 @@
 import type { UmbMediaTypeDetailModel } from '../../types.js';
+import { UmbMediaTypeDetailServerDataSource } from './media-type-detail.server.data-source.js';
 import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
-import { UmbDetailRepositoryBase } from '../../../../core/repository/index.js';
-export declare class UmbMediaTypeDetailRepository extends UmbDetailRepositoryBase<UmbMediaTypeDetailModel> {
+import { UmbDetailRepositoryBase, type UmbRepositoryResponseWithAsObservable } from '../../../../core/repository/index.js';
+export declare class UmbMediaTypeDetailRepository extends UmbDetailRepositoryBase<UmbMediaTypeDetailModel, UmbMediaTypeDetailServerDataSource> {
+    #private;
     constructor(host: UmbControllerHost);
+    /**
+     * Requests multiple media type details by their unique IDs
+     * @param {Array<string>} uniques - The unique IDs of the media types to fetch
+     * @returns {Promise<UmbRepositoryResponseWithAsObservable<Array<UmbMediaTypeDetailModel>>>}
+     * @memberof UmbMediaTypeDetailRepository
+     */
+    requestByUniques(uniques: Array<string>): Promise<UmbRepositoryResponseWithAsObservable<Array<UmbMediaTypeDetailModel> | undefined>>;
 }
 export default UmbMediaTypeDetailRepository;

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

@@ -1,9 +1,37 @@
 import { UmbMediaTypeDetailServerDataSource } from './media-type-detail.server.data-source.js';
 import { UMB_MEDIA_TYPE_DETAIL_STORE_CONTEXT } from './media-type-detail.store.context-token.js';
-import { UmbDetailRepositoryBase } from '../../../../core/repository/index.js';
+import { UmbDetailRepositoryBase, } from '../../../../core/repository/index.js';
 export class UmbMediaTypeDetailRepository extends UmbDetailRepositoryBase {
+    #init;
+    #detailStore;
     constructor(host) {
         super(host, UmbMediaTypeDetailServerDataSource, UMB_MEDIA_TYPE_DETAIL_STORE_CONTEXT);
+        this.#init = this.consumeContext(UMB_MEDIA_TYPE_DETAIL_STORE_CONTEXT, (instance) => {
+            this.#detailStore = instance;
+        })
+            .asPromise({ preventTimeout: true })
+            .catch(() => undefined);
+    }
+    /**
+     * Requests multiple media type details by their unique IDs
+     * @param {Array<string>} uniques - The unique IDs of the media types to fetch
+     * @returns {Promise<UmbRepositoryResponseWithAsObservable<Array<UmbMediaTypeDetailModel>>>}
+     * @memberof UmbMediaTypeDetailRepository
+     */
+    async requestByUniques(uniques) {
+        if (!uniques || uniques.length === 0) {
+            return { data: [] };
+        }
+        await this.#init;
+        const { data, error } = await this.detailDataSource.readMany(uniques);
+        if (data) {
+            data.forEach((item) => this.#detailStore?.append(item));
+        }
+        return {
+            data,
+            error,
+            asObservable: () => this.#detailStore?.byUniques(uniques),
+        };
     }
 }
 export default UmbMediaTypeDetailRepository;

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

@@ -1,19 +1,13 @@
 import type { UmbMediaTypeDetailModel } from '../../types.js';
 import type { UmbDetailDataSource } from '../../../../core/repository/index.js';
-import type { UmbControllerHost } from '../../../../../libs/controller-api/index.js';
+import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
 /**
  * A data source for the Media Type that fetches data from the server
  * @class UmbMediaTypeDetailServerDataSource
  * @implements {RepositoryDetailDataSource}
  */
-export declare class UmbMediaTypeDetailServerDataSource implements UmbDetailDataSource<UmbMediaTypeDetailModel> {
+export declare class UmbMediaTypeDetailServerDataSource extends UmbControllerBase implements UmbDetailDataSource<UmbMediaTypeDetailModel> {
     #private;
-    /**
-     * Creates an instance of UmbMediaTypeDetailServerDataSource.
-     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
-     * @memberof UmbMediaTypeDetailServerDataSource
-     */
-    constructor(host: UmbControllerHost);
     /**
      * Creates a new Media Type scaffold
      * @param {Partial<UmbMediaTypeDetailModel>} [preset]
@@ -30,11 +24,21 @@ export declare class UmbMediaTypeDetailServerDataSource implements UmbDetailData
      * @memberof UmbMediaTypeDetailServerDataSource
      */
     read(unique: string): Promise<{
+        data: UmbMediaTypeDetailModel | undefined;
         error: import("../../../../core/resources/index.js").UmbApiError | import("../../../../core/resources/index.js").UmbCancelError | undefined;
-        data?: undefined;
-    } | {
-        data: UmbMediaTypeDetailModel;
+    }>;
+    /**
+     * Fetches multiple Media Types by their unique IDs from the server
+     * @param {Array<string>} uniques - The unique IDs of the media types to fetch
+     * @returns {*}
+     * @memberof UmbMediaTypeDetailServerDataSource
+     */
+    readMany(uniques: Array<string>): Promise<{
+        data: never[];
         error?: undefined;
+    } | {
+        data: UmbMediaTypeDetailModel[] | undefined;
+        error: import("../../../../core/resources/index.js").UmbApiError | import("../../../../core/resources/index.js").UmbCancelError | undefined;
     }>;
     /**
      * Inserts a new Media Type on the server
@@ -44,11 +48,8 @@ export declare class UmbMediaTypeDetailServerDataSource implements UmbDetailData
      * @memberof UmbMediaTypeDetailServerDataSource
      */
     create(model: UmbMediaTypeDetailModel, parentUnique?: string | null): Promise<{
+        data: UmbMediaTypeDetailModel | undefined;
         error: import("../../../../core/resources/index.js").UmbApiError | import("../../../../core/resources/index.js").UmbCancelError | undefined;
-        data?: undefined;
-    } | {
-        data: UmbMediaTypeDetailModel;
-        error?: undefined;
     }>;
     /**
      * Updates a MediaType on the server
@@ -58,11 +59,8 @@ export declare class UmbMediaTypeDetailServerDataSource implements UmbDetailData
      * @memberof UmbMediaTypeDetailServerDataSource
      */
     update(model: UmbMediaTypeDetailModel): Promise<{
+        data: UmbMediaTypeDetailModel | undefined;
         error: import("../../../../core/resources/index.js").UmbApiError | import("../../../../core/resources/index.js").UmbCancelError | undefined;
-        data?: undefined;
-    } | {
-        data: UmbMediaTypeDetailModel;
-        error?: undefined;
     }>;
     /**
      * Deletes a Media Type on the server
@@ -70,9 +68,5 @@ export declare class UmbMediaTypeDetailServerDataSource implements UmbDetailData
      * @returns {*}
      * @memberof UmbMediaTypeDetailServerDataSource
      */
-    delete(unique: string): Promise<import("../../../../core/resources/index.js").UmbApiResponse<{
-        data: unknown;
-        request: Request;
-        response: Response;
-    }>>;
+    delete(unique: string): Promise<import("../../../../core/resources/index.js").UmbApiWithErrorResponse>;
 }

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

@@ -1,22 +1,14 @@
 import { UMB_MEDIA_TYPE_ENTITY_TYPE } from '../../entity.js';
+import { UmbManagementApiMediaTypeDetailDataRequestManager } from './server-data-source/media-type-detail.server.request-manager.js';
 import { UmbId } from '../../../../core/id/index.js';
-import { MediaTypeService } from '../../../../core/backend-api/index.js';
-import { tryExecute } from '../../../../core/resources/index.js';
+import { UmbControllerBase } from '../../../../../libs/class-api/index.js';
 /**
  * A data source for the Media Type that fetches data from the server
  * @class UmbMediaTypeDetailServerDataSource
  * @implements {RepositoryDetailDataSource}
  */
-export class UmbMediaTypeDetailServerDataSource {
-    #host;
-    /**
-     * Creates an instance of UmbMediaTypeDetailServerDataSource.
-     * @param {UmbControllerHost} host - The controller host for this controller to be appended to
-     * @memberof UmbMediaTypeDetailServerDataSource
-     */
-    constructor(host) {
-        this.#host = host;
-    }
+export class UmbMediaTypeDetailServerDataSource extends UmbControllerBase {
+    #detailRequestManager = new UmbManagementApiMediaTypeDetailDataRequestManager(this);
     /**
      * Creates a new Media Type scaffold
      * @param {Partial<UmbMediaTypeDetailModel>} [preset]
@@ -53,62 +45,24 @@ export class UmbMediaTypeDetailServerDataSource {
     async read(unique) {
         if (!unique)
             throw new Error('Unique is missing');
-        const { data, error } = await tryExecute(this.#host, MediaTypeService.getMediaTypeById({ path: { id: unique } }));
-        if (error || !data) {
-            return { error };
+        const { data, error } = await this.#detailRequestManager.read(unique);
+        return { data: data ? this.#mapServerResponseModelToEntityDetailModel(data) : undefined, error };
+    }
+    /**
+     * Fetches multiple Media Types by their unique IDs from the server
+     * @param {Array<string>} uniques - The unique IDs of the media types to fetch
+     * @returns {*}
+     * @memberof UmbMediaTypeDetailServerDataSource
+     */
+    async readMany(uniques) {
+        if (!uniques || uniques.length === 0) {
+            return { data: [] };
         }
-        // TODO: make data mapper to prevent errors
-        const mediaType = {
-            entityType: UMB_MEDIA_TYPE_ENTITY_TYPE,
-            unique: data.id,
-            name: data.name,
-            alias: data.alias,
-            description: data.description ?? '',
-            icon: data.icon,
-            allowedAtRoot: data.allowedAsRoot,
-            variesByCulture: data.variesByCulture,
-            variesBySegment: data.variesBySegment,
-            isElement: data.isElement,
-            properties: data.properties.map((property) => {
-                return {
-                    id: property.id,
-                    unique: property.id,
-                    container: property.container,
-                    sortOrder: property.sortOrder,
-                    alias: property.alias,
-                    name: property.name,
-                    description: property.description,
-                    dataType: { unique: property.dataType.id },
-                    variesByCulture: property.variesByCulture,
-                    variesBySegment: property.variesBySegment,
-                    validation: property.validation,
-                    appearance: property.appearance,
-                };
-            }),
-            containers: data.containers.map((container) => {
-                return {
-                    id: container.id,
-                    parent: container.parent ? { id: container.parent.id } : null,
-                    name: container.name ?? '',
-                    type: container.type, // TODO: check if the value is valid
-                    sortOrder: container.sortOrder,
-                };
-            }),
-            allowedContentTypes: data.allowedMediaTypes.map((allowedMediaType) => {
-                return {
-                    contentType: { unique: allowedMediaType.mediaType.id },
-                    sortOrder: allowedMediaType.sortOrder,
-                };
-            }),
-            compositions: data.compositions.map((composition) => {
-                return {
-                    contentType: { unique: composition.mediaType.id },
-                    compositionType: composition.compositionType,
-                };
-            }),
-            collection: data.collection ? { unique: data.collection.id } : null,
+        const { data, error } = await this.#detailRequestManager.readMany(uniques);
+        return {
+            data: data?.items?.map((item) => this.#mapServerResponseModelToEntityDetailModel(item)),
+            error,
         };
-        return { data: mediaType };
     }
     /**
      * Inserts a new Media Type on the server
@@ -164,13 +118,8 @@ export class UmbMediaTypeDetailServerDataSource {
             parent: parentUnique ? { id: parentUnique } : null,
             collection: model.collection?.unique ? { id: model.collection?.unique } : null,
         };
-        const { data, error } = await tryExecute(this.#host, MediaTypeService.postMediaType({
-            body,
-        }));
-        if (data && typeof data === 'string') {
-            return this.read(data);
-        }
-        return { error };
+        const { data, error } = await this.#detailRequestManager.create(body);
+        return { data: data ? this.#mapServerResponseModelToEntityDetailModel(data) : undefined, error };
     }
     /**
      * Updates a MediaType on the server
@@ -222,14 +171,8 @@ export class UmbMediaTypeDetailServerDataSource {
             }),
             collection: model.collection?.unique ? { id: model.collection?.unique } : null,
         };
-        const { error } = await tryExecute(this.#host, MediaTypeService.putMediaTypeById({
-            path: { id: model.unique },
-            body,
-        }));
-        if (!error) {
-            return this.read(model.unique);
-        }
-        return { error };
+        const { data, error } = await this.#detailRequestManager.update(model.unique, body);
+        return { data: data ? this.#mapServerResponseModelToEntityDetailModel(data) : undefined, error };
     }
     /**
      * Deletes a Media Type on the server
@@ -240,8 +183,50 @@ export class UmbMediaTypeDetailServerDataSource {
     async delete(unique) {
         if (!unique)
             throw new Error('Unique is missing');
-        return tryExecute(this.#host, MediaTypeService.deleteMediaTypeById({
-            path: { id: unique },
-        }));
+        return this.#detailRequestManager.delete(unique);
+    }
+    #mapServerResponseModelToEntityDetailModel(data) {
+        return {
+            entityType: UMB_MEDIA_TYPE_ENTITY_TYPE,
+            unique: data.id,
+            name: data.name,
+            alias: data.alias,
+            description: data.description ?? '',
+            icon: data.icon,
+            allowedAtRoot: data.allowedAsRoot,
+            variesByCulture: data.variesByCulture,
+            variesBySegment: data.variesBySegment,
+            isElement: data.isElement,
+            properties: data.properties.map((property) => {
+                return {
+                    id: property.id,
+                    unique: property.id,
+                    container: property.container,
+                    sortOrder: property.sortOrder,
+                    alias: property.alias,
+                    name: property.name,
+                    description: property.description,
+                    dataType: { unique: property.dataType.id },
+                    variesByCulture: property.variesByCulture,
+                    variesBySegment: property.variesBySegment,
+                    validation: property.validation,
+                    appearance: property.appearance,
+                };
+            }),
+            containers: data.containers,
+            allowedContentTypes: data.allowedMediaTypes.map((allowedMediaType) => {
+                return {
+                    contentType: { unique: allowedMediaType.mediaType.id },
+                    sortOrder: allowedMediaType.sortOrder,
+                };
+            }),
+            compositions: data.compositions.map((composition) => {
+                return {
+                    contentType: { unique: composition.mediaType.id },
+                    compositionType: composition.compositionType,
+                };
+            }),
+            collection: data.collection ? { unique: data.collection.id } : null,
+        };
     }
 }

package/dist-cms/packages/media/media-types/repository/detail/server-data-source/media-type-detail.server.cache-invalidation.manager.d.ts

@@ -0,0 +1,6 @@
+import { UmbManagementApiDetailDataCacheInvalidationManager } from '../../../../../management-api/index.js';
+import type { UmbControllerHost } from '../../../../../../libs/controller-api/index.js';
+import type { MediaTypeResponseModel } from '../../../../../core/backend-api/index.js';
+export declare class UmbManagementApiMediaTypeDetailDataCacheInvalidationManager extends UmbManagementApiDetailDataCacheInvalidationManager<MediaTypeResponseModel> {
+    constructor(host: UmbControllerHost);
+}

package/dist-cms/packages/media/media-types/repository/detail/server-data-source/media-type-detail.server.cache-invalidation.manager.js

@@ -0,0 +1,10 @@
+import { mediaTypeDetailCache } from './media-type-detail.server.cache.js';
+import { UmbManagementApiDetailDataCacheInvalidationManager } from '../../../../../management-api/index.js';
+export class UmbManagementApiMediaTypeDetailDataCacheInvalidationManager extends UmbManagementApiDetailDataCacheInvalidationManager {
+    constructor(host) {
+        super(host, {
+            dataCache: mediaTypeDetailCache,
+            eventSources: ['Umbraco:CMS:MediaType'],
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { MediaTypeResponseModel } from '../../../../../core/backend-api/index.js';
+import { UmbManagementApiDetailDataCache } from '../../../../../management-api/index.js';
+declare const mediaTypeDetailCache: UmbManagementApiDetailDataCache<MediaTypeResponseModel>;
+export { mediaTypeDetailCache };

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

@@ -0,0 +1,3 @@
+import { UmbManagementApiDetailDataCache } from '../../../../../management-api/index.js';
+const mediaTypeDetailCache = new UmbManagementApiDetailDataCache();
+export { mediaTypeDetailCache };

package/dist-cms/packages/media/media-types/repository/detail/server-data-source/media-type-detail.server.request-manager.d.ts

@@ -0,0 +1,7 @@
+import type { UmbControllerHost } from '../../../../../../libs/controller-api/index.js';
+import { type CreateMediaTypeRequestModel, type MediaTypeResponseModel, type UpdateMediaTypeRequestModel } from '../../../../../core/backend-api/index.js';
+import { UmbManagementApiDetailDataRequestManager } from '../../../../../management-api/index.js';
+export declare class UmbManagementApiMediaTypeDetailDataRequestManager extends UmbManagementApiDetailDataRequestManager<MediaTypeResponseModel, UpdateMediaTypeRequestModel, CreateMediaTypeRequestModel> {
+    #private;
+    constructor(host: UmbControllerHost);
+}

package/dist-cms/packages/media/media-types/repository/detail/server-data-source/media-type-detail.server.request-manager.js

@@ -0,0 +1,18 @@
+/* eslint-disable local-rules/no-direct-api-import */
+import { mediaTypeDetailCache } from './media-type-detail.server.cache.js';
+import { MediaTypeService, } from '../../../../../core/backend-api/index.js';
+import { UmbManagementApiDetailDataRequestManager, UmbManagementApiInFlightRequestCache, } from '../../../../../management-api/index.js';
+export class UmbManagementApiMediaTypeDetailDataRequestManager extends UmbManagementApiDetailDataRequestManager {
+    static #inflightRequestCache = new UmbManagementApiInFlightRequestCache();
+    constructor(host) {
+        super(host, {
+            create: (body) => MediaTypeService.postMediaType({ body }),
+            read: (id) => MediaTypeService.getMediaTypeById({ path: { id } }),
+            update: (id, body) => MediaTypeService.putMediaTypeById({ path: { id }, body }),
+            delete: (id) => MediaTypeService.deleteMediaTypeById({ path: { id } }),
+            readMany: (ids) => MediaTypeService.getMediaTypeBatch({ query: { id: ids } }),
+            dataCache: mediaTypeDetailCache,
+            inflightRequestCache: UmbManagementApiMediaTypeDetailDataRequestManager.#inflightRequestCache,
+        });
+    }
+}

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

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

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

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

package/dist-cms/packages/media/media-types/repository/manifests.js

@@ -1,4 +1,10 @@
 import { manifests as detailManifests } from './detail/manifests.js';
 import { manifests as itemManifests } from './item/manifests.js';
 import { manifests as compositionManifests } from './composition/manifests.js';
-export const manifests = [...detailManifests, ...itemManifests, ...compositionManifests];
+import { manifests as structureManifests } from './structure/manifests.js';
+export const manifests = [
+    ...detailManifests,
+    ...itemManifests,
+    ...compositionManifests,
+    ...structureManifests,
+];

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

@@ -4,11 +4,28 @@ import { UmbContentTypeStructureRepositoryBase } from '../../../../content/conte
 export declare class UmbMediaTypeStructureRepository extends UmbContentTypeStructureRepositoryBase<UmbAllowedMediaTypeModel> {
     #private;
     constructor(host: UmbControllerHost);
+    requestAllowedParentsOf(unique: string): Promise<{
+        error: import("../../../../core/resources/index.js").UmbApiError | import("../../../../core/resources/index.js").UmbCancelError;
+        data?: undefined;
+    } | {
+        data: {
+            unique: string;
+            entityType: string;
+        }[];
+        error?: undefined;
+    }>;
     requestMediaTypesOf({ fileExtension, skip, take, }: {
         fileExtension: string;
         skip?: number;
         take?: number;
-    }): Promise<UmbAllowedMediaTypeModel[]>;
+    }): Promise<{
+        matchedFileExtension: boolean;
+        name: string;
+        description: string | null;
+        icon: string | null;
+        unique: import("../../../../core/entity/index.js").UmbEntityUnique;
+        entityType: string;
+    }[]>;
     requestMediaTypesOfFolders({ skip, take }?: {
         skip?: number | undefined;
         take?: number | undefined;

package/dist-cms/packages/media/media-types/repository/structure/media-type-structure.repository.js

@@ -1,16 +1,20 @@
 import { UmbMediaTypeStructureServerDataSource } from './media-type-structure.server.data-source.js';
 import { UmbContentTypeStructureRepositoryBase } from '../../../../content/content-type/index.js';
 export class UmbMediaTypeStructureRepository extends UmbContentTypeStructureRepositoryBase {
-    #dataSource;
     constructor(host) {
         super(host, UmbMediaTypeStructureServerDataSource);
-        this.#dataSource = new UmbMediaTypeStructureServerDataSource(host);
+    }
+    get #mediaTypeDataSource() {
+        return this._dataSource;
+    }
+    async requestAllowedParentsOf(unique) {
+        return this.#mediaTypeDataSource.getAllowedParentsOf(unique);
     }
     async requestMediaTypesOf({ fileExtension, skip = 0, take = 100, }) {
-        return this.#dataSource.getMediaTypesOfFileExtension({ fileExtension, skip, take });
+        return this.#mediaTypeDataSource.getMediaTypesOfFileExtension({ fileExtension, skip, take });
     }
     async requestMediaTypesOfFolders({ skip = 0, take = 100 } = {}) {
-        return this.#dataSource.getMediaTypesOfFolders({ skip, take });
+        return this.#mediaTypeDataSource.getMediaTypesOfFolders({ skip, take });
     }
 }
 export default UmbMediaTypeStructureRepository;