@umbraco-cms/backoffice 15.4.1 → 16.0.0-rc2

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

@@ -0,0 +1,621 @@
+import { UmbRepositoryDetailsManager, } from '@umbraco-cms/backoffice/repository';
+import { UmbId } from '@umbraco-cms/backoffice/id';
+import { UmbArrayState, partialUpdateFrozenArray, appendToFrozenArray, filterFrozenArray, createObservablePart, } from '@umbraco-cms/backoffice/observable-api';
+import { incrementString } from '@umbraco-cms/backoffice/utils';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbExtensionApiInitializer } from '@umbraco-cms/backoffice/extension-api';
+import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registry';
+import { firstValueFrom } from '@umbraco-cms/backoffice/external/rxjs';
+const UmbFilterDuplicateStrings = (value, index, array) => array.indexOf(value) === index;
+/**
+ * Manages a structure of a Content Type and its properties and containers.
+ * This loads and merges the structures of the Content Type and its inherited and composed Content Types.
+ * To help manage the data, there is two helper classes:
+ * - {@link UmbContentTypePropertyStructureHelper} for managing the structure of properties, optional of another container or root.
+ * - {@link UmbContentTypeContainerStructureHelper} for managing the structure of containers, optional of another container or root.
+ */
+export class UmbContentTypeStructureManager extends UmbControllerBase {
+    #initResolver;
+    #initRejection;
+    #init;
+    #editedTypes;
+    #repository;
+    #initRepositoryResolver;
+    #initRepository;
+    #repoManager;
+    async whenLoaded() {
+        await this.#init;
+        return true;
+    }
+    #ownerContentTypeUnique;
+    #contentTypeObservers;
+    #contentTypes;
+    async getContentTypeCompositions() {
+        return await this.observe(this.contentTypeCompositions).asPromise();
+    }
+    async getOwnerContentTypeCompositions() {
+        return await this.observe(this.ownerContentTypeCompositions).asPromise();
+    }
+    #contentTypeContainers;
+    async getContentTypeProperties() {
+        return await this.observe(this.contentTypeProperties).asPromise();
+    }
+    containerById(id) {
+        return createObservablePart(this.#contentTypeContainers, (x) => x.find((y) => y.id === id));
+    }
+    constructor(host, typeRepository) {
+        super(host);
+        this.#init = new Promise((resolve, reject) => {
+            this.#initResolver = resolve;
+            this.#initRejection = reject;
+        });
+        this.#editedTypes = new UmbArrayState([], (x) => x);
+        this.#initRepository = new Promise((resolve) => {
+            if (this.#repository) {
+                resolve(this.#repository);
+            }
+            else {
+                this.#initRepositoryResolver = resolve;
+            }
+        });
+        this.#contentTypeObservers = new Array();
+        this.#contentTypes = new UmbArrayState([], (x) => x.unique);
+        this.contentTypes = this.#contentTypes.asObservable();
+        this.ownerContentType = this.#contentTypes.asObservablePart((x) => x.find((y) => y.unique === this.#ownerContentTypeUnique));
+        this.ownerContentTypeAlias = createObservablePart(this.ownerContentType, (x) => x?.alias);
+        this.ownerContentTypeName = createObservablePart(this.ownerContentType, (x) => x?.name);
+        this.ownerContentTypeCompositions = createObservablePart(this.ownerContentType, (x) => x?.compositions);
+        this.contentTypeCompositions = this.#contentTypes.asObservablePart((contentTypes) => {
+            return contentTypes.flatMap((x) => x.compositions ?? []);
+        });
+        this.#contentTypeContainers = this.#contentTypes.asObservablePart((contentTypes) => {
+            return contentTypes.flatMap((x) => x.containers ?? []);
+        });
+        this.contentTypeProperties = this.#contentTypes.asObservablePart((contentTypes) => {
+            return contentTypes.flatMap((x) => x.properties ?? []);
+        });
+        this.contentTypeDataTypeUniques = this.#contentTypes.asObservablePart((contentTypes) => {
+            return contentTypes
+                .flatMap((x) => x.properties?.map((p) => p.dataType.unique) ?? [])
+                .filter(UmbFilterDuplicateStrings);
+        });
+        this.contentTypeHasProperties = this.#contentTypes.asObservablePart((contentTypes) => {
+            return contentTypes.some((x) => x.properties.length > 0);
+        });
+        this.contentTypePropertyAliases = createObservablePart(this.contentTypeProperties, (properties) => properties.map((x) => x.alias));
+        this.contentTypeUniques = this.#contentTypes.asObservablePart((x) => x.map((y) => y.unique));
+        this.contentTypeAliases = this.#contentTypes.asObservablePart((x) => x.map((y) => y.alias));
+        this.variesByCulture = createObservablePart(this.ownerContentType, (x) => x?.variesByCulture);
+        this.variesBySegment = createObservablePart(this.ownerContentType, (x) => x?.variesBySegment);
+        if (typeof typeRepository === 'string') {
+            this.#observeRepository(typeRepository);
+        }
+        else {
+            this.#repository = typeRepository;
+            this.#initRepositoryResolver?.(typeRepository);
+        }
+        this.#initRepository.then(() => {
+            if (!this.#repository) {
+                throw new Error('Content Type Structure Manager failed cause it could not initialize or receive the Content Type Detail Repository.');
+            }
+            this.#repoManager = new UmbRepositoryDetailsManager(this, typeRepository);
+            this.observe(this.#repoManager.entries, (entries) => {
+                // Prevent updating once that are have edited here.
+                const entriesToBeUpdated = entries.filter((x) => !(this.#editedTypes.getHasOne(x.unique) && this.#contentTypes.getHasOne(x.unique)));
+                // Remove entries based on no-longer existing uniques:
+                const entriesToBeRemoved = this.#contentTypes
+                    .getValue()
+                    .filter((entry) => !entries.some((x) => x.unique === entry.unique))
+                    .map((x) => x.unique);
+                this.#contentTypes.mute();
+                this.#contentTypes.remove(entriesToBeRemoved);
+                this.#contentTypes.append(entriesToBeUpdated);
+                this.#contentTypes.unmute();
+            }, null);
+        });
+        // Observe all Content Types compositions: [NL]
+        this.observe(this.contentTypeCompositions, (contentTypeCompositions) => {
+            this.#loadContentTypeCompositions(contentTypeCompositions);
+        }, null);
+    }
+    /**
+     * loadType will load the ContentType and all inherited and composed ContentTypes.
+     * This will give us all the structure for properties and containers.
+     * @param {string} unique - The unique of the ContentType to load.
+     * @returns {Promise} - Promise resolved
+     */
+    async loadType(unique) {
+        if (this.#ownerContentTypeUnique === unique) {
+            // Its the same, but we do not know if its done loading jet, so we will wait for the load promise to finish. [NL]
+            await this.#init;
+            return { data: this.getOwnerContentType(), asObservable: () => this.ownerContentType };
+        }
+        await this.#initRepository;
+        this.#clear();
+        this.#ownerContentTypeUnique = unique;
+        if (!unique) {
+            this.#initRejection?.(`Content Type structure manager could not load: ${unique}`);
+            return Promise.reject(new Error('The unique identifier is missing. A valid unique identifier is required to load the content type.'));
+        }
+        this.#repoManager.setUniques([unique]);
+        const result = await this.observe(this.#repoManager.entryByUnique(unique)).asPromise();
+        this.#initResolver?.(result);
+        await this.#init;
+        return { data: result, asObservable: () => this.ownerContentType };
+    }
+    async createScaffold(preset) {
+        await this.#initRepository;
+        this.#clear();
+        const repsonse = await this.#repository.createScaffold(preset);
+        const { data } = repsonse;
+        if (!data) {
+            this.#initRejection?.(`Content Type structure manager could not create scaffold`);
+            return { error: repsonse.error };
+        }
+        this.#ownerContentTypeUnique = data.unique;
+        // Add the new content type to the list of content types, this holds our draft state of this scaffold.
+        this.#contentTypes.appendOne(data);
+        // Make a entry in the repo manager:
+        this.#repoManager.addEntry(data);
+        this.#initResolver?.(data);
+        return repsonse;
+    }
+    /**
+     * Save the owner content type. Notice this is for a Content Type that is already stored on the server.
+     * @returns {Promise} - A promise that will be resolved when the content type is saved.
+     */
+    async save() {
+        await this.#initRepository;
+        const contentType = this.getOwnerContentType();
+        if (!contentType || !contentType.unique)
+            throw new Error('Could not find the Content Type to save');
+        const { error, data } = await this.#repository.save(contentType);
+        if (error || !data) {
+            throw error?.message ?? 'Repository did not return data after save.';
+        }
+        // Update state with latest version:
+        this.#contentTypes.updateOne(contentType.unique, data);
+        // Update entry in the repo manager:
+        this.#repoManager.addEntry(data);
+        return data;
+    }
+    /**
+     * Create the owner content type. Notice this is for a Content Type that is NOT already stored on the server.
+     * @param {string | null} parentUnique - The unique of the parent content type
+     * @returns {Promise} - a promise that is resolved when the content type has been created.
+     */
+    async create(parentUnique) {
+        await this.#initRepository;
+        const contentType = this.getOwnerContentType();
+        if (!contentType || !contentType.unique) {
+            throw new Error('Could not find the Content Type to create');
+        }
+        const { error, data } = await this.#repository.create(contentType, parentUnique);
+        if (error || !data) {
+            throw error?.message ?? 'Repository did not return data after create.';
+        }
+        // Update state with latest version:
+        this.#contentTypes.updateOne(contentType.unique, data);
+        // Let the repo manager know about this new unique, so it can be loaded:
+        this.#repoManager.addEntry(data);
+        return data;
+    }
+    async #loadContentTypeCompositions(contentTypeCompositions) {
+        // Important to wait a JS-cycle, cause this is called by an observation of a state and this results in setting the value for the state(potentially in the same JS-cycle) then we need to make sure we don't trigger a new update before the old subscription chain is completed. [NL]
+        await Promise.resolve();
+        const ownerUnique = this.getOwnerContentTypeUnique();
+        if (!ownerUnique)
+            return;
+        const compositionUniques = contentTypeCompositions?.map((x) => x.contentType.unique) ?? [];
+        const newUniques = [ownerUnique, ...compositionUniques];
+        this.#contentTypes.filter((x) => newUniques.includes(x.unique));
+        this.#repoManager.setUniques(newUniques);
+    }
+    /** Public methods for consuming structure: */
+    ownerContentTypeObservablePart(mappingFunction) {
+        return createObservablePart(this.ownerContentType, mappingFunction);
+    }
+    getOwnerContentType() {
+        return this.#contentTypes.getValue().find((y) => y.unique === this.#ownerContentTypeUnique);
+    }
+    getOwnerContentTypeUnique() {
+        return this.#ownerContentTypeUnique;
+    }
+    getVariesByCulture() {
+        const ownerContentType = this.getOwnerContentType();
+        return ownerContentType?.variesByCulture;
+    }
+    getVariesBySegment() {
+        const ownerContentType = this.getOwnerContentType();
+        return ownerContentType?.variesBySegment;
+    }
+    /**
+     * Figure out if any of the Content Types has a Property.
+     * @returns {boolean} - true if any of the Content Type in this composition has a Property.
+     */
+    getHasProperties() {
+        return this.#contentTypes.getValue().some((y) => y.properties.length > 0);
+    }
+    updateOwnerContentType(entry) {
+        this.#editedTypes.appendOne(this.#ownerContentTypeUnique);
+        this.#contentTypes.updateOne(this.#ownerContentTypeUnique, entry);
+    }
+    getContentTypes() {
+        return this.#contentTypes.getValue();
+    }
+    getContentTypeUniques() {
+        return this.#contentTypes.getValue().map((x) => x.unique);
+    }
+    getContentTypeAliases() {
+        return this.#contentTypes.getValue().map((x) => x.alias);
+    }
+    // TODO: We could move the actions to another class?
+    /**
+     * Ensure a container exists for a specific Content Type. Otherwise clone it.
+     * @param {string} containerId - The container to ensure exists on the given ContentType.
+     * @param {string} contentTypeUnique - The content type to ensure the container for.
+     * @returns {Promise<UmbPropertyTypeContainerModel | undefined>} - The container found or created for the owner ContentType.
+     */
+    async ensureContainerOf(containerId, contentTypeUnique) {
+        await this.#init;
+        const contentType = this.#contentTypes.getValue().find((x) => x.unique === contentTypeUnique);
+        if (!contentType) {
+            throw new Error('Could not find the Content Type to ensure containers for');
+        }
+        const container = contentType?.containers?.find((x) => x.id === containerId);
+        if (!container) {
+            return this.cloneContainerTo(containerId, contentTypeUnique);
+        }
+        return container;
+    }
+    /**
+     * Clone a container to a specific Content Type.
+     * @param {string} containerId - The container to clone, assuming it does not already exist on the given Content Type.
+     * @param {string} toContentTypeUnique - The content type to clone to.
+     * @returns {Promise<UmbPropertyTypeContainerModel | undefined>} - The container cloned or found for the owner ContentType.
+     */
+    async cloneContainerTo(containerId, toContentTypeUnique) {
+        await this.#init;
+        toContentTypeUnique = toContentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.#editedTypes.appendOne(toContentTypeUnique);
+        // Find container.
+        const container = (await firstValueFrom(this.#contentTypeContainers)).find((x) => x.id === containerId);
+        if (!container)
+            throw new Error('Container to clone was not found');
+        const clonedContainer = {
+            ...container,
+            id: UmbId.new(),
+        };
+        if (container.parent) {
+            // Investigate parent container. (See if we have one that matches if not, then clone it.)
+            const parentContainer = await this.ensureContainerOf(container.parent.id, toContentTypeUnique);
+            if (!parentContainer) {
+                throw new Error('Parent container for cloning could not be found or created');
+            }
+            // Clone container.
+            clonedContainer.parent = { id: parentContainer.id };
+        }
+        // Spread containers, so we can append to it, and then update the specific content-type with the new set of containers: [NL]
+        // Correction the spread is removed now, cause we do a filter: [NL]
+        // And then we remove the existing one, to have the more local one replacing it. [NL]
+        const containers = [
+            ...(this.#contentTypes.getValue().find((x) => x.unique === toContentTypeUnique)?.containers ?? []),
+        ];
+        containers.push(clonedContainer);
+        this.#contentTypes.updateOne(toContentTypeUnique, { containers });
+        return clonedContainer;
+    }
+    ensureContainerNames(contentTypeUnique, type, parentId = null) {
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.getOwnerContainers(type, parentId)?.forEach((container) => {
+            if (container.name === '') {
+                const newName = 'Unnamed';
+                this.#editedTypes.appendOne(contentTypeUnique);
+                this.updateContainer(null, container.id, {
+                    name: this.makeContainerNameUniqueForOwnerContentType(container.id, newName, type, parentId) ?? newName,
+                });
+            }
+        });
+    }
+    async createContainer(contentTypeUnique, parentId = null, type = 'Group', sortOrder) {
+        await this.#init;
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.#editedTypes.appendOne(contentTypeUnique);
+        if (parentId) {
+            const duplicatedParentContainer = await this.ensureContainerOf(parentId, contentTypeUnique);
+            if (!duplicatedParentContainer) {
+                throw new Error('Parent container for creating a new container could not be found or created');
+            }
+            parentId = duplicatedParentContainer.id;
+        }
+        const container = {
+            id: UmbId.new(),
+            parent: parentId ? { id: parentId } : null,
+            name: '',
+            type: type,
+            sortOrder: sortOrder ?? 0,
+        };
+        return this.insertContainer(contentTypeUnique, container);
+    }
+    async insertContainer(contentTypeUnique, container) {
+        await this.#init;
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        const newContainer = { ...container };
+        const type = newContainer.type;
+        const parentId = newContainer.parent?.id ?? null;
+        // If we have a parent, we need to ensure it exists, and then update the parent property with the new container id.
+        if (newContainer.parent) {
+            const parentContainer = await this.ensureContainerOf(newContainer.parent.id, contentTypeUnique);
+            if (!parentContainer) {
+                throw new Error('Container for inserting property could not be found or created');
+            }
+            newContainer.parent.id = parentContainer.id;
+        }
+        // Ensure
+        this.ensureContainerNames(contentTypeUnique, type, parentId);
+        const frozenContainers = this.#contentTypes.getValue().find((x) => x.unique === contentTypeUnique)?.containers ?? [];
+        const containers = appendToFrozenArray(frozenContainers, newContainer, (x) => x.id === newContainer.id);
+        this.#contentTypes.updateOne(contentTypeUnique, { containers });
+        return newContainer;
+    }
+    makeEmptyContainerName(containerId, containerType, parentId = null) {
+        return (this.makeContainerNameUniqueForOwnerContentType(containerId, 'Unnamed', containerType, parentId) ?? 'Unnamed');
+    }
+    makeContainerNameUniqueForOwnerContentType(containerId, newName, containerType, parentId = null) {
+        const ownerRootContainers = this.getOwnerContainers(containerType, parentId); //getRootContainers() can't differentiates between compositions and locals
+        if (!ownerRootContainers) {
+            return null;
+        }
+        let changedName = newName;
+        while (ownerRootContainers.find((con) => con.name === changedName && con.id !== containerId)) {
+            changedName = incrementString(changedName);
+        }
+        return changedName === newName ? null : changedName;
+    }
+    async updateContainer(contentTypeUnique, containerId, partialUpdate) {
+        await this.#init;
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.#editedTypes.appendOne(contentTypeUnique);
+        /*
+        // If we have a container, we need to ensure it exists, and then update the container with the new parent id.
+        if (containerId) {
+            const container = await this.ensureContainerOf(containerId, contentTypeUnique);
+            if (!container) {
+                throw new Error('Container for inserting property could not be found or created');
+            }
+            // Correct containerId to the local one: [NL]
+            containerId = container.id;
+        }
+        */
+        const frozenContainers = this.#contentTypes.getValue().find((x) => x.unique === contentTypeUnique)?.containers ?? [];
+        const ownerContainer = frozenContainers.find((x) => x.id === containerId);
+        if (!ownerContainer) {
+            console.error('We do not have this container on the requested id, we should clone the container and append the change to it. [NL]');
+        }
+        const containers = partialUpdateFrozenArray(frozenContainers, partialUpdate, (x) => x.id === containerId);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        // TODO: fix TS partial complaint
+        this.#contentTypes.updateOne(contentTypeUnique, { containers });
+    }
+    async removeContainer(contentTypeUnique, containerId = null, args) {
+        await this.#init;
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.#editedTypes.appendOne(contentTypeUnique);
+        const contentType = this.#contentTypes.getValue().find((x) => x.unique === contentTypeUnique);
+        if (!contentType) {
+            throw new Error('Could not find the Content Type to remove container from');
+        }
+        const frozenContainers = contentType.containers ?? [];
+        const removedContainerIds = frozenContainers
+            .filter((x) => x.id === containerId || x.parent?.id === containerId)
+            .map((x) => x.id);
+        const containers = frozenContainers.filter((x) => x.id !== containerId && x.parent?.id !== containerId);
+        const updates = { containers };
+        if (args?.preventRemovingProperties !== true) {
+            updates.properties = contentType.properties.filter((x) => x.container ? !removedContainerIds.some((ids) => ids === x.container?.id) : true);
+        }
+        this.#contentTypes.updateOne(contentTypeUnique, updates);
+    }
+    async insertProperty(contentTypeUnique, property) {
+        await this.#init;
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.#editedTypes.appendOne(contentTypeUnique);
+        // If we have a container, we need to ensure it exists, and then update the container with the new parent id. [NL]
+        if (property.container) {
+            this.#contentTypes.mute();
+            const container = await this.ensureContainerOf(property.container.id, contentTypeUnique);
+            this.#contentTypes.unmute();
+            if (!container) {
+                throw new Error('Container for inserting property could not be found or created');
+            }
+            // Unfreeze object, while settings container.id
+            property = { ...property, container: { id: container.id } };
+        }
+        if (property.sortOrder === undefined) {
+            property.sortOrder = 0;
+        }
+        const frozenProperties = this.#contentTypes.getValue().find((x) => x.unique === contentTypeUnique)?.properties ?? [];
+        const properties = appendToFrozenArray(frozenProperties, property, (x) => x.unique === property.unique);
+        this.#contentTypes.updateOne(contentTypeUnique, { properties });
+    }
+    async removeProperty(contentTypeUnique, propertyUnique) {
+        await this.#init;
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.#editedTypes.appendOne(contentTypeUnique);
+        const frozenProperties = this.#contentTypes.getValue().find((x) => x.unique === contentTypeUnique)?.properties ?? [];
+        const properties = filterFrozenArray(frozenProperties, (x) => x.unique !== propertyUnique);
+        this.#contentTypes.updateOne(contentTypeUnique, { properties });
+    }
+    async updateProperty(contentTypeUnique, propertyUnique, partialUpdate) {
+        await this.#init;
+        contentTypeUnique = contentTypeUnique ?? this.#ownerContentTypeUnique;
+        this.#editedTypes.appendOne(contentTypeUnique);
+        const frozenProperties = this.#contentTypes.getValue().find((x) => x.unique === contentTypeUnique)?.properties ?? [];
+        const properties = partialUpdateFrozenArray(frozenProperties, partialUpdate, (x) => x.unique === propertyUnique);
+        this.#contentTypes.updateOne(contentTypeUnique, { properties });
+    }
+    // TODO: Refactor: These property methods, should maybe be named without structure in their name.
+    async propertyStructureById(propertyUnique) {
+        await this.#init;
+        return this.#contentTypes.asObservablePart((docTypes) => {
+            for (const docType of docTypes) {
+                const foundProp = docType.properties?.find((property) => property.unique === propertyUnique);
+                if (foundProp) {
+                    return foundProp;
+                }
+            }
+            return undefined;
+        });
+    }
+    async propertyStructureByAlias(propertyAlias) {
+        await this.#init;
+        return this.#contentTypes.asObservablePart((docTypes) => {
+            for (const docType of docTypes) {
+                const foundProp = docType.properties?.find((property) => property.alias === propertyAlias);
+                if (foundProp) {
+                    return foundProp;
+                }
+            }
+            return undefined;
+        });
+    }
+    async getPropertyStructureById(propertyUnique) {
+        await this.#init;
+        for (const docType of this.#contentTypes.getValue()) {
+            const foundProp = docType.properties?.find((property) => property.unique === propertyUnique);
+            if (foundProp) {
+                return foundProp;
+            }
+        }
+        return undefined;
+    }
+    async getOwnerPropertyById(propertyUnique) {
+        await this.#init;
+        return this.getOwnerContentType()?.properties?.find((property) => property.unique === propertyUnique);
+    }
+    async getPropertyStructureByAlias(propertyAlias) {
+        await this.#init;
+        for (const docType of this.#contentTypes.getValue()) {
+            const foundProp = docType.properties?.find((property) => property.alias === propertyAlias);
+            if (foundProp) {
+                return foundProp;
+            }
+        }
+        return undefined;
+    }
+    hasPropertyStructuresOf(containerId) {
+        return this.#contentTypes.asObservablePart((docTypes) => {
+            return (docTypes.find((docType) => {
+                return docType.properties?.find((property) => property.container?.id === containerId);
+            }) !== undefined);
+        });
+    }
+    rootPropertyStructures() {
+        return this.propertyStructuresOf(null);
+    }
+    propertyStructuresOf(containerId) {
+        return this.#contentTypes.asObservablePart((docTypes) => {
+            const props = [];
+            docTypes.forEach((docType) => {
+                docType.properties?.forEach((property) => {
+                    if (property.container?.id === containerId) {
+                        props.push(property);
+                    }
+                });
+            });
+            return props;
+        });
+    }
+    rootContainers(containerType) {
+        return createObservablePart(this.#contentTypeContainers, (data) => {
+            return data.filter((x) => x.parent === null && x.type === containerType);
+        });
+    }
+    async getRootContainers(containerType) {
+        return (await firstValueFrom(this.#contentTypeContainers)).filter((x) => x.parent === null && x.type === containerType);
+    }
+    async hasRootContainers(containerType) {
+        return createObservablePart(this.#contentTypeContainers, (data) => {
+            return data.filter((x) => x.parent === null && x.type === containerType).length > 0;
+        });
+    }
+    ownerContainersOf(containerType, parentId) {
+        return this.ownerContentTypeObservablePart((x) => x?.containers?.filter((x) => (parentId ? x.parent?.id === parentId : x.parent === null) && x.type === containerType) ?? []);
+    }
+    getOwnerContainerById(id) {
+        return this.getOwnerContentType()?.containers?.find((x) => x.id === id);
+    }
+    getOwnerContainers(containerType, parentId) {
+        return this.getOwnerContentType()?.containers?.filter((x) => (parentId ? x.parent?.id === parentId : x.parent === null) && x.type === containerType);
+    }
+    isOwnerContainer(containerId) {
+        return this.getOwnerContentType()?.containers?.filter((x) => x.id === containerId);
+    }
+    containersOfParentId(parentId, containerType) {
+        return createObservablePart(this.#contentTypeContainers, (data) => {
+            return data.filter((x) => x.parent?.id === parentId && x.type === containerType);
+        });
+    }
+    // In future this might need to take parentName(parentId lookup) into account as well? otherwise containers that share same name and type will always be merged, but their position might be different and they should not be merged. [NL]
+    containersByNameAndType(name, containerType) {
+        return createObservablePart(this.#contentTypeContainers, (data) => {
+            return data.filter((x) => x.name === name && x.type === containerType);
+        });
+    }
+    containersByNameAndTypeAndParent(name, containerType, parentName, parentType) {
+        return createObservablePart(this.#contentTypeContainers, (data) => {
+            return data.filter((x) => 
+            // Match name and type:
+            x.name === name &&
+                x.type === containerType &&
+                // If we look for a parent name, then we need to match that as well:
+                (parentName !== null
+                    ? // And we have a parent on this container, then we need to match the parent name and type as well
+                        x.parent
+                            ? data.some((y) => x.parent.id === y.id && y.name === parentName && y.type === parentType)
+                            : false
+                    : // if we do not have a parent then its not a match
+                        x.parent === null));
+        });
+    }
+    getContentTypeOfContainer(containerId) {
+        return this.#contentTypes
+            .getValue()
+            .find((contentType) => contentType.containers.some((c) => c.id === containerId));
+    }
+    contentTypeOfProperty(propertyId) {
+        return this.#contentTypes.asObservablePart((contentTypes) => contentTypes.find((contentType) => contentType.properties.some((p) => p.unique === propertyId)));
+    }
+    #observeRepository(repositoryAlias) {
+        if (!repositoryAlias)
+            throw new Error('Content Type structure manager must have a repository alias.');
+        new UmbExtensionApiInitializer(this, umbExtensionsRegistry, repositoryAlias, [this._host], (permitted, ctrl) => {
+            this.#repository = permitted ? ctrl.api : undefined;
+            if (this.#repository) {
+                this.#initRepositoryResolver?.(this.#repository);
+            }
+        });
+    }
+    /**
+     * Get all property aliases for the content type including inherited and composed content types.
+     * @returns {Promise<Array<string>>} - A promise that will be resolved with the list of all content type property aliases.
+     */
+    async getContentTypePropertyAliases() {
+        return this.#contentTypes
+            .getValue()
+            .flatMap((x) => x.properties?.map((y) => y.alias) ?? [])
+            .filter(UmbFilterDuplicateStrings);
+    }
+    #clear() {
+        this.#contentTypeObservers.forEach((observer) => observer.destroy());
+        this.#contentTypeObservers = [];
+        this.#repoManager?.clear();
+        this.#contentTypes.setValue([]);
+        this.#ownerContentTypeUnique = undefined;
+    }
+    destroy() {
+        this.#contentTypes.destroy();
+        super.destroy();
+    }
+}