@umbraco-cms/backoffice 14.0.0-a8030000 → 14.0.0-abd22b1c

package/dist-cms/packages/core/content-type/content-type-container-structure-helper.class.js

@@ -14,7 +14,7 @@ export class UmbContentTypeContainerStructureHelper {
         // Containers defined in data might be more than actual containers to display as we merge them by name.
         // Direct containers are the containers defining the total of this container(Multiple containers with the same name and type)
         this._ownerAlikeContainers = [];
-        // Owner containers are containers owned by the owner Document Type (The specific one up for editing)
+        // Owner containers are containers owned by the owner Content Type (The specific one up for editing)
         this._ownerContainers = [];
         // State containing the merged containers (only one pr. name):
         this.#containers = new UmbArrayState([], (x) => x.id);
@@ -172,7 +172,7 @@ export class UmbContentTypeContainerStructureHelper {
         await this.#init;
         if (!this.#structure)
             return;
-        const newName = this.#structure.makeContainerNameUniqueForOwnerDocument(name, this._childType, containerParentId) ?? name;
+        const newName = this.#structure.makeContainerNameUniqueForOwnerContentType(name, this._childType, containerParentId) ?? name;
         return await this.partialUpdateContainer(containerId, { name: newName });
     }
 }

package/dist-cms/packages/core/content-type/content-type-property-structure-helper.class.js

@@ -16,7 +16,7 @@ export class UmbContentTypePropertyStructureHelper {
         this.#propertyStructure.sortBy((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
     }
     get ownerDocumentTypes() {
-        return this.#structure?.documentTypes;
+        return this.#structure?.contentTypes;
     }
     setStructureManager(structure) {
         this.#structure = structure;

package/dist-cms/packages/core/content-type/content-type-structure-manager.class.d.ts

@@ -6,8 +6,8 @@ export type PropertyContainerTypes = 'Group' | 'Tab';
 type T = DocumentTypeResponseModel;
 export declare class UmbContentTypePropertyStructureManager<R extends UmbDetailRepository<T> = UmbDetailRepository<T>> {
     #private;
-    readonly documentTypes: import("rxjs").Observable<DocumentTypeResponseModel[]>;
-    private readonly _documentTypeContainers;
+    readonly contentTypes: import("rxjs").Observable<DocumentTypeResponseModel[]>;
+    private readonly _contentTypeContainers;
     constructor(host: UmbControllerHostElement, typeRepository: R);
     /**
      * loadType will load the node type and all inherited and composed types.
@@ -27,26 +27,26 @@ export declare class UmbContentTypePropertyStructureManager<R extends UmbDetailR
     create(): Promise<boolean>;
     private _ensureType;
     private _loadType;
-    _observeDocumentType(data: T): Promise<void>;
-    private _loadDocumentTypeCompositions;
+    _observeContentType(data: T): Promise<void>;
+    private _loadContentTypeCompositions;
     /** Public methods for consuming structure: */
-    ownerDocumentType(): import("rxjs").Observable<DocumentTypeResponseModel | undefined>;
-    getOwnerDocumentType(): DocumentTypeResponseModel | undefined;
-    updateOwnerDocumentType(entry: T): void;
+    ownerContentType(): import("rxjs").Observable<DocumentTypeResponseModel | undefined>;
+    getOwnerContentType(): DocumentTypeResponseModel | undefined;
+    updateOwnerContentType(entry: T): void;
     createContainer(contentTypeId: string | null, parentId?: string | null, type?: PropertyContainerTypes, sortOrder?: number): Promise<PropertyTypeContainerModelBaseModel>;
-    makeContainerNameUniqueForOwnerDocument(newName: string, containerType?: PropertyContainerTypes, parentId?: string | null): string | null;
-    updateContainer(documentTypeId: string | null, containerId: string, partialUpdate: Partial<PropertyTypeContainerModelBaseModel>): Promise<void>;
-    removeContainer(documentTypeKey: string | null, containerId?: string | null): Promise<void>;
+    makeContainerNameUniqueForOwnerContentType(newName: string, containerType?: PropertyContainerTypes, parentId?: string | null): string | null;
+    updateContainer(contentTypeId: string | null, containerId: string, partialUpdate: Partial<PropertyTypeContainerModelBaseModel>): Promise<void>;
+    removeContainer(contentTypeId: string | null, containerId?: string | null): Promise<void>;
     createPropertyScaffold(containerId?: string | null, sortOrder?: number): PropertyTypeModelBaseModel;
-    createProperty(documentTypeId: string | null, containerId?: string | null, sortOrder?: number): Promise<PropertyTypeModelBaseModel>;
-    insertProperty(documentTypeId: string | null, property: PropertyTypeModelBaseModel): Promise<void>;
-    removeProperty(documentTypeId: string | null, propertyId: string): Promise<void>;
-    updateProperty(documentTypeId: string | null, propertyId: string, partialUpdate: Partial<PropertyTypeModelBaseModel>): Promise<void>;
+    createProperty(contentTypeId: string | null, containerId?: string | null, sortOrder?: number): Promise<PropertyTypeModelBaseModel>;
+    insertProperty(contentTypeId: string | null, property: PropertyTypeModelBaseModel): Promise<void>;
+    removeProperty(contentTypeId: string | null, propertyId: string): Promise<void>;
+    updateProperty(contentTypeId: string | null, propertyId: string, partialUpdate: Partial<PropertyTypeModelBaseModel>): Promise<void>;
     propertyStructureById(propertyId: string): Promise<import("rxjs").Observable<PropertyTypeModelBaseModel | undefined>>;
     propertyStructureByAlias(propertyAlias: string): Promise<import("rxjs").Observable<PropertyTypeModelBaseModel | undefined>>;
     getPropertyStructureById(propertyId: string): Promise<PropertyTypeModelBaseModel | undefined>;
     getPropertyStructureByAlias(propertyAlias: string): Promise<PropertyTypeModelBaseModel | undefined>;
-    ownerDocumentTypeObservablePart<PartResult>(mappingFunction: MappingFunction<T, PartResult>): import("rxjs").Observable<PartResult | undefined>;
+    ownerContentTypeObservablePart<PartResult>(mappingFunction: MappingFunction<T, PartResult>): import("rxjs").Observable<PartResult | undefined>;
     hasPropertyStructuresOf(containerId: string | null): import("rxjs").Observable<boolean>;
     rootPropertyStructures(): import("rxjs").Observable<PropertyTypeModelBaseModel[]>;
     propertyStructuresOf(containerId: string | null): import("rxjs").Observable<PropertyTypeModelBaseModel[]>;

package/dist-cms/packages/core/content-type/content-type-structure-manager.class.js

@@ -6,25 +6,25 @@ export class UmbContentTypePropertyStructureManager {
     #host;
     #init;
     #contentTypeRepository;
-    #ownerDocumentTypeId;
-    #documentTypeObservers;
-    #documentTypes;
+    #ownerContentTypeId;
+    #contentTypeObservers;
+    #contentTypes;
     #containers;
     constructor(host, typeRepository) {
-        this.#documentTypeObservers = new Array();
-        this.#documentTypes = new UmbArrayState([], (x) => x.id);
-        this.documentTypes = this.#documentTypes.asObservable();
-        this._documentTypeContainers = this.#documentTypes.asObservablePart((x) => x.flatMap((x) => x.containers ?? []));
+        this.#contentTypeObservers = new Array();
+        this.#contentTypes = new UmbArrayState([], (x) => x.id);
+        this.contentTypes = this.#contentTypes.asObservable();
+        this._contentTypeContainers = this.#contentTypes.asObservablePart((x) => x.flatMap((x) => x.containers ?? []));
         this.#containers = new UmbArrayState([], (x) => x.id);
         this.#host = host;
         this.#contentTypeRepository = typeRepository;
-        new UmbObserverController(host, this.documentTypes, (documentTypes) => {
-            documentTypes.forEach((documentType) => {
-                this._loadDocumentTypeCompositions(documentType);
+        new UmbObserverController(host, this.contentTypes, (contentTypes) => {
+            contentTypes.forEach((contentType) => {
+                this._loadContentTypeCompositions(contentType);
             });
         });
-        new UmbObserverController(host, this._documentTypeContainers, (documentTypeContainers) => {
-            this.#containers.next(documentTypeContainers);
+        new UmbObserverController(host, this._contentTypeContainers, (contentTypeContainers) => {
+            this.#containers.next(contentTypeContainers);
         });
     }
     /**
@@ -33,7 +33,7 @@ export class UmbContentTypePropertyStructureManager {
      */
     async loadType(id) {
         this._reset();
-        this.#ownerDocumentTypeId = id;
+        this.#ownerContentTypeId = id;
         const promiseResult = this._loadType(id);
         this.#init = promiseResult;
         await this.#init;
@@ -46,24 +46,23 @@ export class UmbContentTypePropertyStructureManager {
         const { data } = await this.#contentTypeRepository.createScaffold(parentId);
         if (!data)
             return {};
-        this.#ownerDocumentTypeId = data.id;
-        this.#init = this._observeDocumentType(data);
+        this.#ownerContentTypeId = data.id;
+        this.#init = this._observeContentType(data);
         await this.#init;
         return { data };
     }
     async save() {
-        const documentType = this.getOwnerDocumentType();
-        if (!documentType || !documentType.id)
+        const contentType = this.getOwnerContentType();
+        if (!contentType || !contentType.id)
             return false;
-        await this.#contentTypeRepository.save(documentType.id, documentType);
+        await this.#contentTypeRepository.save(contentType.id, contentType);
         return true;
     }
     async create() {
-        const documentType = this.getOwnerDocumentType();
-        if (!documentType || !documentType.id)
+        const contentType = this.getOwnerContentType();
+        if (!contentType || !contentType.id)
             return false;
-        //const value = documentType as CreateDocumentTypeRequestModel & { id: string };
-        const { data } = await this.#contentTypeRepository.create(documentType);
+        const { data } = await this.#contentTypeRepository.create(contentType);
         if (!data)
             return false;
         await this.loadType(data.id);
@@ -72,7 +71,7 @@ export class UmbContentTypePropertyStructureManager {
     async _ensureType(id) {
         if (!id)
             return;
-        if (this.#documentTypes.getValue().find((x) => x.id === id))
+        if (this.#contentTypes.getValue().find((x) => x.id === id))
             return;
         await this._loadType(id);
     }
@@ -82,50 +81,43 @@ export class UmbContentTypePropertyStructureManager {
         const { data } = await this.#contentTypeRepository.requestById(id);
         if (!data)
             return {};
-        await this._observeDocumentType(data);
+        await this._observeContentType(data);
         return { data };
     }
-    async _observeDocumentType(data) {
+    async _observeContentType(data) {
         if (!data.id)
             return;
         // Load inherited and composed types:
-        this._loadDocumentTypeCompositions(data);
-        this.#documentTypeObservers.push(new UmbObserverController(this.#host, await this.#contentTypeRepository.byId(data.id), (docType) => {
+        this._loadContentTypeCompositions(data);
+        this.#contentTypeObservers.push(new UmbObserverController(this.#host, await this.#contentTypeRepository.byId(data.id), (docType) => {
             if (docType) {
                 // TODO: Handle if there was changes made to the owner document type in this context.
                 /*
                 possible easy solutions could be to notify user wether they want to update(Discard the changes to accept the new ones).
                  */
-                this.#documentTypes.appendOne(docType);
+                this.#contentTypes.appendOne(docType);
             }
         }));
     }
-    async _loadDocumentTypeCompositions(documentType) {
-        documentType.compositions?.forEach((composition) => {
+    async _loadContentTypeCompositions(contentType) {
+        contentType.compositions?.forEach((composition) => {
             this._ensureType(composition.id);
         });
     }
-    /*
-    private async _initDocumentTypeContainers(documentType: T) {
-        documentType.containers?.forEach((container) => {
-            this.#containers.appendOne({ ...container, _ownerDocumentTypeKey: documentType.id });
-        });
-    }
-    */
     /** Public methods for consuming structure: */
-    ownerDocumentType() {
-        return this.#documentTypes.asObservablePart((x) => x.find((y) => y.id === this.#ownerDocumentTypeId));
+    ownerContentType() {
+        return this.#contentTypes.asObservablePart((x) => x.find((y) => y.id === this.#ownerContentTypeId));
     }
-    getOwnerDocumentType() {
-        return this.#documentTypes.getValue().find((y) => y.id === this.#ownerDocumentTypeId);
+    getOwnerContentType() {
+        return this.#contentTypes.getValue().find((y) => y.id === this.#ownerContentTypeId);
     }
-    updateOwnerDocumentType(entry) {
-        this.#documentTypes.updateOne(this.#ownerDocumentTypeId, entry);
+    updateOwnerContentType(entry) {
+        this.#contentTypes.updateOne(this.#ownerContentTypeId, entry);
     }
     // We could move the actions to another class?
     async createContainer(contentTypeId, parentId = null, type = 'Group', sortOrder) {
         await this.#init;
-        contentTypeId = contentTypeId ?? this.#ownerDocumentTypeId;
+        contentTypeId = contentTypeId ?? this.#ownerContentTypeId;
         const container = {
             id: UmbId.new(),
             parentId: parentId ?? null,
@@ -133,12 +125,12 @@ export class UmbContentTypePropertyStructureManager {
             type: type,
             sortOrder: sortOrder ?? 0,
         };
-        const containers = [...(this.#documentTypes.getValue().find((x) => x.id === contentTypeId)?.containers ?? [])];
+        const containers = [...(this.#contentTypes.getValue().find((x) => x.id === contentTypeId)?.containers ?? [])];
         containers.push(container);
-        this.#documentTypes.updateOne(contentTypeId, { containers });
+        this.#contentTypes.updateOne(contentTypeId, { containers });
         return container;
     }
-    makeContainerNameUniqueForOwnerDocument(newName, containerType = 'Tab', parentId = null) {
+    makeContainerNameUniqueForOwnerContentType(newName, containerType = 'Tab', parentId = null) {
         const ownerRootContainers = this.getOwnerContainers(containerType); //getRootContainers() can't differentiates between compositions and locals
         let changedName = newName;
         if (ownerRootContainers) {
@@ -149,19 +141,19 @@ export class UmbContentTypePropertyStructureManager {
         }
         return null;
     }
-    async updateContainer(documentTypeId, containerId, partialUpdate) {
+    async updateContainer(contentTypeId, containerId, partialUpdate) {
         await this.#init;
-        documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
-        const frozenContainers = this.#documentTypes.getValue().find((x) => x.id === documentTypeId)?.containers ?? [];
+        contentTypeId = contentTypeId ?? this.#ownerContentTypeId;
+        const frozenContainers = this.#contentTypes.getValue().find((x) => x.id === contentTypeId)?.containers ?? [];
         const containers = partialUpdateFrozenArray(frozenContainers, partialUpdate, (x) => x.id === containerId);
-        this.#documentTypes.updateOne(documentTypeId, { containers });
+        this.#contentTypes.updateOne(contentTypeId, { containers });
     }
-    async removeContainer(documentTypeKey, containerId = null) {
+    async removeContainer(contentTypeId, containerId = null) {
         await this.#init;
-        documentTypeKey = documentTypeKey ?? this.#ownerDocumentTypeId;
-        const frozenContainers = this.#documentTypes.getValue().find((x) => x.id === documentTypeKey)?.containers ?? [];
+        contentTypeId = contentTypeId ?? this.#ownerContentTypeId;
+        const frozenContainers = this.#contentTypes.getValue().find((x) => x.id === contentTypeId)?.containers ?? [];
         const containers = frozenContainers.filter((x) => x.id !== containerId);
-        this.#documentTypes.updateOne(documentTypeKey, { containers });
+        this.#contentTypes.updateOne(contentTypeId, { containers });
     }
     createPropertyScaffold(containerId = null, sortOrder) {
         const property = {
@@ -186,40 +178,40 @@ export class UmbContentTypePropertyStructureManager {
         }; // Sort order was not allowed when this was written.
         return property;
     }
-    async createProperty(documentTypeId, containerId = null, sortOrder) {
+    async createProperty(contentTypeId, containerId = null, sortOrder) {
         await this.#init;
-        documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
+        contentTypeId = contentTypeId ?? this.#ownerContentTypeId;
         const property = this.createPropertyScaffold(containerId, sortOrder);
-        const properties = [...(this.#documentTypes.getValue().find((x) => x.id === documentTypeId)?.properties ?? [])];
+        const properties = [...(this.#contentTypes.getValue().find((x) => x.id === contentTypeId)?.properties ?? [])];
         properties.push(property);
-        this.#documentTypes.updateOne(documentTypeId, { properties });
+        this.#contentTypes.updateOne(contentTypeId, { properties });
         return property;
     }
-    async insertProperty(documentTypeId, property) {
+    async insertProperty(contentTypeId, property) {
         await this.#init;
-        documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
-        const frozenProperties = this.#documentTypes.getValue().find((x) => x.id === documentTypeId)?.properties ?? [];
+        contentTypeId = contentTypeId ?? this.#ownerContentTypeId;
+        const frozenProperties = this.#contentTypes.getValue().find((x) => x.id === contentTypeId)?.properties ?? [];
         const properties = appendToFrozenArray(frozenProperties, property, (x) => x.id === property.id);
-        this.#documentTypes.updateOne(documentTypeId, { properties });
+        this.#contentTypes.updateOne(contentTypeId, { properties });
     }
-    async removeProperty(documentTypeId, propertyId) {
+    async removeProperty(contentTypeId, propertyId) {
         await this.#init;
-        documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
-        const frozenProperties = this.#documentTypes.getValue().find((x) => x.id === documentTypeId)?.properties ?? [];
+        contentTypeId = contentTypeId ?? this.#ownerContentTypeId;
+        const frozenProperties = this.#contentTypes.getValue().find((x) => x.id === contentTypeId)?.properties ?? [];
         const properties = filterFrozenArray(frozenProperties, (x) => x.id !== propertyId);
-        this.#documentTypes.updateOne(documentTypeId, { properties });
+        this.#contentTypes.updateOne(contentTypeId, { properties });
     }
-    async updateProperty(documentTypeId, propertyId, partialUpdate) {
+    async updateProperty(contentTypeId, propertyId, partialUpdate) {
         await this.#init;
-        documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
-        const frozenProperties = this.#documentTypes.getValue().find((x) => x.id === documentTypeId)?.properties ?? [];
+        contentTypeId = contentTypeId ?? this.#ownerContentTypeId;
+        const frozenProperties = this.#contentTypes.getValue().find((x) => x.id === contentTypeId)?.properties ?? [];
         const properties = partialUpdateFrozenArray(frozenProperties, partialUpdate, (x) => x.id === propertyId);
-        this.#documentTypes.updateOne(documentTypeId, { properties });
+        this.#contentTypes.updateOne(contentTypeId, { properties });
     }
     // TODO: Refactor: These property methods, should maybe be named without structure in their name.
     async propertyStructureById(propertyId) {
         await this.#init;
-        return this.#documentTypes.asObservablePart((docTypes) => {
+        return this.#contentTypes.asObservablePart((docTypes) => {
             for (const docType of docTypes) {
                 const foundProp = docType.properties?.find((property) => property.id === propertyId);
                 if (foundProp) {
@@ -231,7 +223,7 @@ export class UmbContentTypePropertyStructureManager {
     }
     async propertyStructureByAlias(propertyAlias) {
         await this.#init;
-        return this.#documentTypes.asObservablePart((docTypes) => {
+        return this.#contentTypes.asObservablePart((docTypes) => {
             for (const docType of docTypes) {
                 const foundProp = docType.properties?.find((property) => property.alias === propertyAlias);
                 if (foundProp) {
@@ -243,7 +235,7 @@ export class UmbContentTypePropertyStructureManager {
     }
     async getPropertyStructureById(propertyId) {
         await this.#init;
-        for (const docType of this.#documentTypes.getValue()) {
+        for (const docType of this.#contentTypes.getValue()) {
             const foundProp = docType.properties?.find((property) => property.id === propertyId);
             if (foundProp) {
                 return foundProp;
@@ -253,7 +245,7 @@ export class UmbContentTypePropertyStructureManager {
     }
     async getPropertyStructureByAlias(propertyAlias) {
         await this.#init;
-        for (const docType of this.#documentTypes.getValue()) {
+        for (const docType of this.#contentTypes.getValue()) {
             const foundProp = docType.properties?.find((property) => property.alias === propertyAlias);
             if (foundProp) {
                 return foundProp;
@@ -261,30 +253,14 @@ export class UmbContentTypePropertyStructureManager {
         }
         return undefined;
     }
-    /*
-    rootDocumentTypeName() {
-        return this.#documentTypes.asObservablePart((docTypes) => {
-            const docType = docTypes.find((x) => x.id === this.#rootDocumentTypeKey);
-            return docType?.name ?? '';
-        });
-    }
-    */
-    ownerDocumentTypeObservablePart(mappingFunction) {
-        return this.#documentTypes.asObservablePart((docTypes) => {
-            const docType = docTypes.find((x) => x.id === this.#ownerDocumentTypeId);
+    ownerContentTypeObservablePart(mappingFunction) {
+        return this.#contentTypes.asObservablePart((docTypes) => {
+            const docType = docTypes.find((x) => x.id === this.#ownerContentTypeId);
             return docType ? mappingFunction(docType) : undefined;
         });
     }
-    /*
-    nameOfDocumentType(id: string) {
-        return this.#documentTypes.asObservablePart((docTypes) => {
-            const docType = docTypes.find((x) => x.id === id);
-            return docType?.name ?? '';
-        });
-    }
-    */
     hasPropertyStructuresOf(containerId) {
-        return this.#documentTypes.asObservablePart((docTypes) => {
+        return this.#contentTypes.asObservablePart((docTypes) => {
             return (docTypes.find((docType) => {
                 return docType.properties?.find((property) => property.containerId === containerId);
             }) !== undefined);
@@ -294,7 +270,7 @@ export class UmbContentTypePropertyStructureManager {
         return this.propertyStructuresOf(null);
     }
     propertyStructuresOf(containerId) {
-        return this.#documentTypes.asObservablePart((docTypes) => {
+        return this.#contentTypes.asObservablePart((docTypes) => {
             const props = [];
             docTypes.forEach((docType) => {
                 docType.properties?.forEach((property) => {
@@ -320,13 +296,13 @@ export class UmbContentTypePropertyStructureManager {
         });
     }
     ownerContainersOf(containerType) {
-        return this.ownerDocumentTypeObservablePart((x) => x.containers?.filter((x) => x.type === containerType) ?? []);
+        return this.ownerContentTypeObservablePart((x) => x.containers?.filter((x) => x.type === containerType) ?? []);
     }
     getOwnerContainers(containerType, parentId = null) {
-        return this.getOwnerDocumentType()?.containers?.filter((x) => x.parentId === parentId && x.type === containerType);
+        return this.getOwnerContentType()?.containers?.filter((x) => x.parentId === parentId && x.type === containerType);
     }
     isOwnerContainer(containerId) {
-        return this.getOwnerDocumentType()?.containers?.filter((x) => x.id === containerId);
+        return this.getOwnerContentType()?.containers?.filter((x) => x.id === containerId);
     }
     containersOfParentKey(parentId, containerType) {
         return this.#containers.asObservablePart((data) => {
@@ -340,14 +316,14 @@ export class UmbContentTypePropertyStructureManager {
         });
     }
     _reset() {
-        this.#documentTypeObservers.forEach((observer) => observer.destroy());
-        this.#documentTypeObservers = [];
-        this.#documentTypes.next([]);
+        this.#contentTypeObservers.forEach((observer) => observer.destroy());
+        this.#contentTypeObservers = [];
+        this.#contentTypes.next([]);
         this.#containers.next([]);
     }
     destroy() {
         this._reset();
-        this.#documentTypes.complete();
+        this.#contentTypes.complete();
         this.#containers.complete();
     }
 }

package/dist-cms/packages/documents/document-types/entity-actions/manifests.js

@@ -10,7 +10,7 @@ const entityActions = [
         weight: 900,
         meta: {
             icon: 'umb:trash',
-            label: 'Delete (TBD)',
+            label: 'Delete',
             repositoryAlias: DOCUMENT_TYPE_REPOSITORY_ALIAS,
             api: UmbDeleteEntityAction,
             entityTypes: [entityType],

package/dist-cms/packages/documents/document-types/repository/document-type-item.store.d.ts

@@ -0,0 +1,20 @@
+import { DocumentTypeItemResponseModel } from '../../../../external/backend-api/index.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+import { UmbItemStore, UmbStoreBase } from '../../../core/store/index.js';
+/**
+ * @export
+ * @class UmbDocumentTypeItemStore
+ * @extends {UmbStoreBase}
+ * @description - Data Store for Document Type items
+ */
+export declare class UmbDocumentTypeItemStore extends UmbStoreBase<DocumentTypeItemResponseModel> implements UmbItemStore<DocumentTypeItemResponseModel> {
+    /**
+     * Creates an instance of UmbDocumentTypeItemStore.
+     * @param {UmbControllerHostElement} host
+     * @memberof UmbDocumentTypeItemStore
+     */
+    constructor(host: UmbControllerHostElement);
+    items(ids: Array<string>): import("rxjs").Observable<DocumentTypeItemResponseModel[]>;
+}
+export declare const UMB_DOCUMENT_TYPE_ITEM_STORE_CONTEXT_TOKEN: UmbContextToken<UmbDocumentTypeItemStore, UmbDocumentTypeItemStore>;

package/dist-cms/packages/documents/document-types/repository/document-type-item.store.js

@@ -0,0 +1,23 @@
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbStoreBase } from '../../../core/store/index.js';
+import { UmbArrayState } from '../../../../libs/observable-api/index.js';
+/**
+ * @export
+ * @class UmbDocumentTypeItemStore
+ * @extends {UmbStoreBase}
+ * @description - Data Store for Document Type items
+ */
+export class UmbDocumentTypeItemStore extends UmbStoreBase {
+    /**
+     * Creates an instance of UmbDocumentTypeItemStore.
+     * @param {UmbControllerHostElement} host
+     * @memberof UmbDocumentTypeItemStore
+     */
+    constructor(host) {
+        super(host, UMB_DOCUMENT_TYPE_ITEM_STORE_CONTEXT_TOKEN.toString(), new UmbArrayState([], (x) => x.id));
+    }
+    items(ids) {
+        return this._data.asObservablePart((items) => items.filter((item) => ids.includes(item.id ?? '')));
+    }
+}
+export const UMB_DOCUMENT_TYPE_ITEM_STORE_CONTEXT_TOKEN = new UmbContextToken('UmbDocumentTypeItemStore');

package/dist-cms/packages/documents/document-types/repository/document-type.repository.d.ts

@@ -24,6 +24,11 @@ export declare class UmbDocumentTypeRepository implements UmbTreeRepository<Enti
         error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
         asObservable: () => import("rxjs").Observable<EntityTreeItemResponseModel[]>;
     }>;
+    requestItems(ids: Array<string>): Promise<{
+        data: import("../../../../external/backend-api/index.js").DocumentTypeItemResponseModel[] | undefined;
+        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
+        asObservable: () => import("rxjs").Observable<import("../../../../external/backend-api/index.js").DocumentTypeItemResponseModel[]>;
+    }>;
     requestItemsLegacy(ids: Array<string>): Promise<{
         data: any[] | undefined;
         error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
@@ -43,28 +48,7 @@ export declare class UmbDocumentTypeRepository implements UmbTreeRepository<Enti
     byId(id: string): Promise<import("rxjs").Observable<DocumentTypeResponseModel | undefined>>;
     requestAllowedChildTypesOf(id: string): Promise<import("../../../../shared/repository/index.js").DataSourceResponse<any>>;
     create(documentType: ItemType): Promise<{
-        data: {
-            alias?: string | undefined;
-            name?: string | undefined;
-            description?: string | null | undefined;
-            icon?: string | undefined;
-            allowedAsRoot?: boolean | undefined;
-            variesByCulture?: boolean | undefined;
-            variesBySegment?: boolean | undefined;
-            isElement?: boolean | undefined;
-            properties?: import("../../../../external/backend-api/index.js").PropertyTypeModelBaseModel[] | undefined;
-            containers?: import("../../../../external/backend-api/index.js").PropertyTypeContainerModelBaseModel[] | undefined;
-            allowedContentTypes?: import("../../../../external/backend-api/index.js").ContentTypeSortModel[] | undefined;
-            compositions?: import("../../../../external/backend-api/index.js").ContentTypeCompositionModel[] | undefined;
-            id?: string | undefined;
-            allowedTemplateIds?: string[] | undefined;
-            defaultTemplateId?: string | null | undefined;
-            cleanup?: import("../../../../external/backend-api/index.js").ContentTypeCleanupModel | undefined;
-        };
-        error?: undefined;
-    } | {
         error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
-        data?: undefined;
     }>;
     save(id: string, item: UpdateDocumentTypeRequestModel): Promise<{
         error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;

package/dist-cms/packages/documents/document-types/repository/document-type.repository.js

@@ -2,6 +2,8 @@ import { UmbDocumentTypeTreeServerDataSource } from './sources/document-type.tre
 import { UmbDocumentTypeServerDataSource } from './sources/document-type.server.data.js';
 import { UMB_DOCUMENT_TYPE_TREE_STORE_CONTEXT_TOKEN } from './document-type.tree.store.js';
 import { UMB_DOCUMENT_TYPE_STORE_CONTEXT_TOKEN } from './document-type.store.js';
+import { UMB_DOCUMENT_TYPE_ITEM_STORE_CONTEXT_TOKEN } from './document-type-item.store.js';
+import { UmbDocumentTypeItemServerDataSource } from './sources/document-type-item.server.data.js';
 import { UmbContextConsumerController } from '../../../../libs/context-api/index.js';
 import { UMB_NOTIFICATION_CONTEXT_TOKEN } from '../../../core/notification/index.js';
 export class UmbDocumentTypeRepository {
@@ -11,12 +13,15 @@ export class UmbDocumentTypeRepository {
     #treeStore;
     #detailDataSource;
     #detailStore;
+    #itemSource;
+    #itemStore;
     #notificationContext;
     constructor(host) {
         this.#host = host;
         // TODO: figure out how spin up get the correct data source
         this.#treeSource = new UmbDocumentTypeTreeServerDataSource(this.#host);
         this.#detailDataSource = new UmbDocumentTypeServerDataSource(this.#host);
+        this.#itemSource = new UmbDocumentTypeItemServerDataSource(this.#host);
         this.#init = Promise.all([
             new UmbContextConsumerController(this.#host, UMB_DOCUMENT_TYPE_TREE_STORE_CONTEXT_TOKEN, (instance) => {
                 this.#treeStore = instance;
@@ -24,12 +29,14 @@ export class UmbDocumentTypeRepository {
             new UmbContextConsumerController(this.#host, UMB_DOCUMENT_TYPE_STORE_CONTEXT_TOKEN, (instance) => {
                 this.#detailStore = instance;
             }),
+            new UmbContextConsumerController(this.#host, UMB_DOCUMENT_TYPE_ITEM_STORE_CONTEXT_TOKEN, (instance) => {
+                this.#itemStore = instance;
+            }),
             new UmbContextConsumerController(this.#host, UMB_NOTIFICATION_CONTEXT_TOKEN, (instance) => {
                 this.#notificationContext = instance;
             }),
         ]);
     }
-    // TODO: Trash
     // TODO: Move
     async requestTreeRoot() {
         await this.#init;
@@ -60,6 +67,16 @@ export class UmbDocumentTypeRepository {
         }
         return { data, error, asObservable: () => this.#treeStore.childrenOf(parentId) };
     }
+    async requestItems(ids) {
+        if (!ids)
+            throw new Error('Document Type Ids are missing');
+        await this.#init;
+        const { data, error } = await this.#itemSource.getItems(ids);
+        if (data) {
+            this.#itemStore?.appendItems(data);
+        }
+        return { data, error, asObservable: () => this.#itemStore.items(ids) };
+    }
     async requestItemsLegacy(ids) {
         await this.#init;
         if (!ids) {
@@ -117,25 +134,13 @@ export class UmbDocumentTypeRepository {
     // Could potentially be general methods:
     async create(documentType) {
         if (!documentType || !documentType.id)
-            throw new Error('Template is missing');
+            throw new Error('Document Type is missing');
         await this.#init;
-        const { error, data } = await this.#detailDataSource.insert(documentType);
-        if (!error && data) {
-            // TODO: The parts here is a hack, when we can trust the IDs we send, then this should be removed/changed:
-            const splitResultUrl = data.split('/');
-            const newId = splitResultUrl[splitResultUrl.length - 1];
-            // Temporary hack while we are not in control of IDs:
-            const newDocument = { ...(await this.requestById(newId)).data };
-            if (newDocument) {
-                const notification = { data: { message: `Document Type created` } };
-                this.#notificationContext?.peek('positive', notification);
-                await this.requestRootTreeItems();
-                // TODO: currently we cannot put this data into our store, cause we don't have the right ID, as the server currently changes it (and other ids of it, container-id and property-id)
-                //this.#detailStore?.append(newDocument);
-                //const treeItem = createTreeItem(newDocument);
-                //this.#treeStore?.appendItems([treeItem]);
-                return { data: newDocument };
-            }
+        const { error } = await this.#detailDataSource.insert(documentType);
+        if (!error) {
+            this.#detailStore?.append(documentType);
+            const treeItem = createTreeItem(documentType);
+            this.#treeStore?.appendItems([treeItem]);
         }
         return { error };
     }
@@ -170,9 +175,10 @@ export class UmbDocumentTypeRepository {
             // TODO: we currently don't use the detail store for anything.
             // Consider to look up the data before fetching from the server.
             // Consider notify a workspace if a template is deleted from the store while someone is editing it.
+            // TODO: would be nice to align the stores on methods/methodNames.
             this.#detailStore?.remove([id]);
             this.#treeStore?.removeItem(id);
-            // TODO: would be nice to align the stores on methods/methodNames.
+            this.#itemStore?.removeItem(id);
         }
         return { error };
     }