@umbraco-cms/backoffice 16.3.0-rc3 → 17.0.0-beta

package/dist-cms/packages/content/content/workspace/content-detail-workspace-base.js

@@ -8,12 +8,11 @@ import { firstValueFrom, map } from '../../../../external/rxjs/index.js';
 import { umbOpenModal } from '../../../core/modal/index.js';
 import { UmbContentTypeStructureManager } from '../../content-type/index.js';
 import { UmbDataTypeDetailRepository, UmbDataTypeItemRepositoryManager } from '../../../data-type/index.js';
-import { UmbDeprecation, UmbReadOnlyVariantGuardManager } from '../../../core/utils/index.js';
+import { UmbReadOnlyVariantGuardManager } from '../../../core/utils/index.js';
 import { UmbEntityDetailWorkspaceContextBase, UmbWorkspaceSplitViewManager } from '../../../core/workspace/index.js';
 import { UmbEntityUpdatedEvent, UmbRequestReloadChildrenOfEntityEvent, UmbRequestReloadStructureForEntityEvent, } from '../../../core/entity-action/index.js';
 import { UmbLanguageCollectionRepository } from '../../../language/index.js';
-import { UmbPropertyValuePresetVariantBuilderController, UmbVariantPropertyGuardManager, } from '../../../core/property/index.js';
-import { UmbSegmentCollectionRepository } from '../../../segment/index.js';
+import { UmbPropertyValueFlatMapperController, UmbPropertyValuePresetVariantBuilderController, UmbVariantPropertyGuardManager, } from '../../../core/property/index.js';
 import { UmbVariantId } from '../../../core/variant/index.js';
 import { UMB_ACTION_EVENT_CONTEXT } from '../../../core/action/index.js';
 import { UMB_VALIDATION_CONTEXT, UMB_VALIDATION_EMPTY_LOCALIZATION_KEY, UmbDataPathVariantQuery, UmbServerModelValidatorContext, UmbValidationController, } from '../../../core/validation/index.js';
@@ -44,8 +43,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
     // TODO: Optimize this so it uses either a App Language Context? [NL]
     #languageRepository;
     #languages;
-    #segmentRepository;
-    #segments;
     #variantValidationContexts;
     getVariantValidationContext(variantId) {
         return this.#variantValidationContexts.find((x) => x.getVariantId()?.compare(variantId));
@@ -86,9 +83,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
          * @internal
          */
         this.languages = this.#languages.asObservable();
-        this.#segmentRepository = new UmbSegmentCollectionRepository(this);
-        this.#segments = new UmbArrayState([], (x) => x.unique);
-        this._segments = this.#segments.asObservable();
+        this._segments = new UmbArrayState([], (x) => x.alias);
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         this._variantOptionsFilter = (variantOption) => true;
         this.#variantValidationContexts = [];
@@ -115,7 +110,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.varies = this.structure.ownerContentTypeObservablePart((x) => x ? x.variesByCulture || x.variesBySegment : undefined);
         this.collection = new UmbContentCollectionManager(this, this.structure, args.collectionAlias);
         new UmbContentValidationToHintsManager(this, this.structure, this.validationContext, this.view.hints);
-        this.variantOptions = mergeObservables([this.variesByCulture, this.variesBySegment, this.variants, this.languages, this._segments], ([variesByCulture, variesBySegment, variants, languages, segments]) => {
+        this.variantOptions = mergeObservables([this.variesByCulture, this.variesBySegment, this.variants, this.languages, this._segments.asObservable()], ([variesByCulture, variesBySegment, variants, languages, segments]) => {
             if ((variesByCulture || variesBySegment) === undefined) {
                 return [];
             }
@@ -153,14 +148,16 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
                     segment: null,
                     unique: new UmbVariantId().toString(),
                 };
-                const segmentsForInvariantCulture = segments.map((segment) => {
+                // Find all segments that are either generic (undefined) or invariant (null)
+                const availableSegments = segments.filter((s) => !s.cultures);
+                const segmentsForInvariantCulture = availableSegments.map((segment) => {
                     return {
-                        variant: variants.find((x) => x.culture === null && x.segment === segment.unique),
+                        variant: variants.find((x) => x.culture === null && x.segment === segment.alias),
                         language: languages.find((x) => x.isDefault),
                         segmentInfo: segment,
                         culture: null,
-                        segment: segment.unique,
-                        unique: new UmbVariantId(null, segment.unique).toString(),
+                        segment: segment.alias,
+                        unique: new UmbVariantId(null, segment.alias).toString(),
                     };
                 });
                 return [invariantCulture, ...segmentsForInvariantCulture];
@@ -169,20 +166,22 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             if (variesByCulture && variesBySegment) {
                 return languages.flatMap((language) => {
                     const culture = {
-                        variant: variants.find((x) => x.culture === language.unique),
+                        variant: variants.find((x) => x.culture === language.unique && x.segment === null),
                         language,
                         culture: language.unique,
                         segment: null,
                         unique: new UmbVariantId(language.unique).toString(),
                     };
-                    const segmentsForCulture = segments.map((segment) => {
+                    // Find all segments that are either generic (undefined) or that contains this culture
+                    const availableSegments = segments.filter((s) => !s.cultures || s.cultures.includes(language.unique));
+                    const segmentsForCulture = availableSegments.map((segment) => {
                         return {
-                            variant: variants.find((x) => x.culture === language.unique && x.segment === segment.unique),
+                            variant: variants.find((x) => x.culture === language.unique && x.segment === segment.alias),
                             language,
                             segmentInfo: segment,
                             culture: language.unique,
-                            segment: segment.unique,
-                            unique: new UmbVariantId(language.unique, segment.unique).toString(),
+                            segment: segment.alias,
+                            unique: new UmbVariantId(language.unique, segment.alias).toString(),
                         };
                     });
                     return [culture, ...segmentsForCulture];
@@ -222,32 +221,40 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.observe(this.variesBySegment, (varies) => {
             this._data.setVariesBySegment(varies);
             this.#variesBySegment = varies;
+            if (varies) {
+                this.loadSegments();
+            }
+            else {
+                this._segments.setValue([]);
+            }
         }, null);
         this.observe(this.structure.contentTypeDataTypeUniques, (dataTypeUniques) => {
             this.#dataTypeItemManager.setUniques(dataTypeUniques);
         }, null);
         this.loadLanguages();
-        this.#loadSegments();
     }
     async loadLanguages() {
         // TODO: If we don't end up having a Global Context for languages, then we should at least change this into using a asObservable which should be returned from the repository. [Nl]
         const { data } = await this.#languageRepository.requestCollection({});
         this.#languages.setValue(data?.items ?? []);
     }
-    async #loadSegments() {
-        const { data } = await this.#segmentRepository.requestCollection({});
-        this.#segments.setValue(data?.items ?? []);
+    async loadSegments() {
+        console.warn(`UmbContentDetailWorkspaceContextBase: Segments are not implemented in the workspace context for "${this.getEntityType()}" types.`);
+        this._segments.setValue([]);
     }
-    async _scaffoldProcessData(data) {
+    /**
+     * @deprecated Call `_processIncomingData` instead. `_scaffoldProcessData` will be removed in v.18.
+     */
+    _scaffoldProcessData(data) {
+        return this._processIncomingData(data);
+    }
+    async _processIncomingData(data) {
         const contentTypeUnique = data[this.#contentTypePropertyName].unique;
         if (!contentTypeUnique) {
             throw new Error(`Could not find content type unique on property '${this.#contentTypePropertyName}'`);
         }
         // Load the content type structure, usually this comes from the data, but in this case we are making the data, and we need this to be able to complete the data. [NL]
         await this.structure.loadType(contentTypeUnique);
-        /**
-         * TODO: Should we also set Preset Values when loading Content, because maybe content contains uncreated Cultures or Segments.
-         */
         // Set culture and segment for all values:
         const cultures = this.#languages.getValue().map((x) => x.unique);
         if (this.structure.variesBySegment) {
@@ -284,11 +291,15 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         if (segments) {
             controller.setSegments(segments);
         }
-        const presetValues = await controller.create(valueDefinitions, {
+        controller.setValues(data.values);
+        const processedValues = await controller.create(valueDefinitions, {
             entityType: this.getEntityType(),
             entityUnique: data.unique,
             entityTypeUnique: contentTypeUnique,
         });
+        /*
+        const presetValues = ...
+
         // Don't just set the values, as we could have some already populated from a blueprint.
         // If we have a value from both a blueprint and a preset, use the latter as priority.
         const dataValues = [...data.values];
@@ -298,13 +309,14 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             const matchingDataValueIndex = dataValues.findIndex((v) => v.alias === presetValue.alias && variantId.compare(v));
             if (matchingDataValueIndex > -1) {
                 dataValues[matchingDataValueIndex] = presetValue;
-            }
-            else {
+            } else {
                 dataValues.push(presetValue);
             }
         }
+
         data.values = dataValues;
-        return data;
+        */
+        return { ...data, values: processedValues };
     }
     /**
      * Get the name of a variant
@@ -330,9 +342,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
      * @memberof UmbContentDetailWorkspaceContextBase
      */
     setName(name, variantId) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        // TODO: fix type error
         this._data.updateVariantData(variantId ?? UmbVariantId.CreateInvariant(), { name });
     }
     /**
@@ -468,15 +477,54 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         const currentData = this.getData();
         if (currentData) {
             const values = appendToFrozenArray(currentData.values ?? [], entry, (x) => x.alias === alias && variantId.compare(x));
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            // TODO: fix type error
+            this.#ensureVariantsExistsForProperty(variantId, entry);
             this._data.updateCurrent({ values });
-            // TODO: Ideally we should move this type of logic to the act of saving [NL]
-            this._data.ensureVariantData(variantId);
         }
         this.finishPropertyValueChange();
     }
+    async #ensureVariantsExistsForProperty(variantId, entry) {
+        // TODO: Implement queueing of these operations to ensure this does not execute too often. [NL]
+        const cultureOptions = await firstValueFrom(this.variantOptions);
+        let valueVariantIds = [];
+        // Find inner values to determine if any of this holds variants that needs to be created.
+        if (variantId.isInvariant() && entry.value) {
+            valueVariantIds = await new UmbPropertyValueFlatMapperController(this).flatMap(entry, (property) => {
+                return UmbVariantId.CreateFromPartial(property);
+            });
+        }
+        valueVariantIds.push(variantId);
+        /**
+         * Handling of Not-Culture but Segment variant properties: [NL]
+         * We need to ensure variant-entries across all culture variants for the given segment variant, when er property is configured to vary by segment but not culture.
+         * This is the only different case, in all other cases its fine to just target the given variant.
+         */
+        const variantOptionsToCheck = [];
+        for (const variant of valueVariantIds) {
+            // If a non-culture but segmented value, then spread across all cultures for the given segment:
+            if (this.getVariesByCulture() && variant.culture === null && variant.segment !== null) {
+                // get all culture options:
+                for (const cultureOption of cultureOptions) {
+                    if (cultureOption.segment === variant.segment) {
+                        variantOptionsToCheck.push(UmbVariantId.Create(cultureOption));
+                    }
+                }
+                // If a non-segmented but culture-variant value, then spread across all segments for the given culture:
+            }
+            if (this.getVariesBySegment() && variant.culture !== null && variant.segment === null) {
+                // get all culture options:
+                for (const cultureOption of cultureOptions) {
+                    if (cultureOption.culture === variant.culture) {
+                        variantOptionsToCheck.push(UmbVariantId.Create(cultureOption));
+                    }
+                }
+            }
+            else if (cultureOptions.some((x) => variant.compare(x))) {
+                // otherwise we can parse the variant-id on:
+                variantOptionsToCheck.push(variant);
+            }
+        }
+        this._data.ensureVariantsData(variantOptionsToCheck);
+    }
     initiatePropertyValueChange() {
         this._data.initiatePropertyValueChange();
     }
@@ -511,21 +559,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         };
     }
     /* validation */
-    /**
-     * Run the mandatory validation for the save data
-     * @deprecated Use the public runMandatoryValidationForSaveData instead. Will be removed in v. 17.
-     * @protected
-     * @param {DetailModelType} saveData - The data to validate
-     * @memberof UmbContentDetailWorkspaceContextBase
-     */
-    async _runMandatoryValidationForSaveData(saveData, variantIds = []) {
-        new UmbDeprecation({
-            removeInVersion: '17',
-            deprecated: '_runMandatoryValidationForSaveData',
-            solution: 'Use the public runMandatoryValidationForSaveData instead.',
-        }).warn();
-        this.runMandatoryValidationForSaveData(saveData, variantIds);
-    }
     /**
      * Run the mandatory validation for the save data
      * @param {DetailModelType} saveData - The data to validate
@@ -660,17 +693,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             await this.performCreateOrUpdate(variantIds, saveData);
         }
     }
-    /**
-     * Perform the create or update of the content
-     * @deprecated Use the public performCreateOrUpdate instead. Will be removed in v. 17.
-     * @protected
-     * @param {Array<UmbVariantId>} variantIds
-     * @param {DetailModelType} saveData
-     * @memberof UmbContentDetailWorkspaceContextBase
-     */
-    async _performCreateOrUpdate(variantIds, saveData) {
-        await this.performCreateOrUpdate(variantIds, saveData);
-    }
     /**
      * Perform the create or update of the content
      * @param {Array<UmbVariantId>} variantIds - The variant ids to save

package/dist-cms/packages/content/content/workspace/views/edit/content-editor.element.d.ts

@@ -3,6 +3,7 @@ import type { UmbWorkspaceViewElement } from '../../../../../core/workspace/inde
 import './content-editor-tab.element.js';
 export declare class UmbContentWorkspaceViewEditElement extends UmbLitElement implements UmbWorkspaceViewElement {
     #private;
+    private _loaded;
     private _hasRootGroups;
     private _routes;
     private _tabs?;
@@ -11,7 +12,7 @@ export declare class UmbContentWorkspaceViewEditElement extends UmbLitElement im
     private _hintMap;
     private _tabsStructureHelper;
     constructor();
-    render(): import("lit-html").TemplateResult<1> | undefined;
+    render(): import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }
 export default UmbContentWorkspaceViewEditElement;

package/dist-cms/packages/content/content/workspace/views/edit/content-editor.element.js

@@ -22,6 +22,7 @@ let UmbContentWorkspaceViewEditElement = class UmbContentWorkspaceViewEditElemen
     #structureManager;
     constructor() {
         super();
+        this._loaded = false;
         this._hasRootGroups = false;
         this._routes = [];
         this._activePath = '';
@@ -45,6 +46,9 @@ let UmbContentWorkspaceViewEditElement = class UmbContentWorkspaceViewEditElemen
             this.#structureManager = workspaceContext?.structure;
             this._tabsStructureHelper.setStructureManager(workspaceContext?.structure);
             this.#observeRootGroups();
+            this.observe(this.#structureManager?.contentTypeLoaded, (loaded) => {
+                this._loaded = loaded ?? false;
+            }, 'observeContentTypeLoaded');
         });
     }
     async #observeRootGroups() {
@@ -138,8 +142,9 @@ let UmbContentWorkspaceViewEditElement = class UmbContentWorkspaceViewEditElemen
         view.provideAt(component);
     }
     render() {
-        if (!this._routes || !this._tabs)
-            return;
+        if (!this._loaded || !this._routes || this._routes.length === 0 || !this._tabs) {
+            return html `<umb-view-loader></umb-view-loader>`;
+        }
         return html `
 			<umb-body-layout header-fit-height>
 				${this._routerPath && (this._tabs.length > 1 || (this._tabs.length === 1 && this._hasRootGroups))
@@ -194,6 +199,9 @@ let UmbContentWorkspaceViewEditElement = class UmbContentWorkspaceViewEditElemen
 		`,
     ]; }
 };
+__decorate([
+    state()
+], UmbContentWorkspaceViewEditElement.prototype, "_loaded", void 0);
 __decorate([
     state()
 ], UmbContentWorkspaceViewEditElement.prototype, "_hasRootGroups", void 0);

package/dist-cms/packages/content/content-type/conditions/types.d.ts

@@ -14,10 +14,6 @@ export type UmbWorkspaceContentTypeAliasConditionConfig = UmbConditionConfigBase
      */
     oneOf?: Array<string>;
 };
-/**
- * @deprecated Use `UmbWorkspaceContentTypeAliasConditionConfig` instead. This will be removed in Umbraco 17.
- */
-export type WorkspaceContentTypeAliasConditionConfig = UmbWorkspaceContentTypeAliasConditionConfig;
 declare global {
     interface UmbExtensionConditionConfigMap {
         umbWorkspaceContentTypeAliasConditionConfig: UmbWorkspaceContentTypeAliasConditionConfig;

package/dist-cms/packages/content/content-type/index.d.ts

@@ -6,8 +6,3 @@ export * from './structure/index.js';
 export * from './workspace/index.js';
 export type * from './composition/index.js';
 export type * from './types.js';
-/**
- * @deprecated Use `UmbPropertyTypeBasedPropertyElement` from `@umbraco-cms/backoffice/content` instead.
- * Export will be removed in version 17.
- */
-export { UmbPropertyTypeBasedPropertyElement } from '../content/components/property-type-based-property/property-type-based-property.element.js';

package/dist-cms/packages/content/content-type/index.js

@@ -4,8 +4,3 @@ export * from './global-components/index.js';
 export * from './repository/index.js';
 export * from './structure/index.js';
 export * from './workspace/index.js';
-/**
- * @deprecated Use `UmbPropertyTypeBasedPropertyElement` from `@umbraco-cms/backoffice/content` instead.
- * Export will be removed in version 17.
- */
-export { UmbPropertyTypeBasedPropertyElement } from '../content/components/property-type-based-property/property-type-based-property.element.js';

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

@@ -36,13 +36,13 @@ export class UmbContentTypeContainerStructureHelper extends UmbControllerBase {
         this.#childContainers = new UmbArrayState([], (x) => x.id);
         // State containing the merged containers (only one pr. name):
         this.#legacyMergedChildContainers = new UmbArrayState([], (x) => x.id);
-        this.#childContainersMerged = new UmbArrayState([], (x) => x.path);
+        this.#childContainersMerged = new UmbArrayState([], (x) => x.key);
         this.childContainers = this.#childContainersMerged.asObservable();
         // Owner containers are containers owned by the owner Content Type (The specific one up for editing)
         this.#ownerChildContainers = [];
         this.#hasProperties = new UmbBooleanState(false);
         this.hasProperties = this.#hasProperties.asObservable();
-        // TODO: Implement UmbDeprecated and Obsolete this from v.17 [NL]
+        // TODO: Implement UmbDeprecation and Obsolete this from v.17 [NL]
         this.#legacyMergeLogic = false;
         // LEGACY method:
         this.#legacyPerformContainerMerge = (containers) => {
@@ -60,7 +60,7 @@ export class UmbContentTypeContainerStructureHelper extends UmbControllerBase {
         this.#childContainersMerged.sortBy((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
         this.#legacyMergedChildContainers.sortBy((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
     }
-    // TODO: Implement UmbDeprecated and Obsolete this from v.17 [NL]
+    // TODO: Implement UmbDeprecation and Obsolete this from v.17 [NL]
     #legacyMergeLogic;
     #startLegacy() {
         if (this.#legacyMergeLogic)

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

@@ -56,6 +56,7 @@ export declare class UmbContentTypeStructureManager<T extends UmbContentTypeMode
     /** Public methods for consuming structure: */
     ownerContentTypeObservablePart<R>(mappingFunction: MappingFunction<T | undefined, R>): Observable<R>;
     getOwnerContentType(): T | undefined;
+    getOwnerContentTypeName(): string | undefined;
     getOwnerContentTypeUnique(): string | undefined;
     getVariesByCulture(): boolean | undefined;
     getVariesBySegment(): boolean | undefined;
@@ -93,16 +94,14 @@ export declare class UmbContentTypeStructureManager<T extends UmbContentTypeMode
         type: UmbPropertyContainerTypes;
         sortOrder: number;
     }>;
-    makeEmptyContainerName(containerId: string, legacyContainerType?: UmbPropertyContainerTypes, legacyParentId?: string | null): string;
+    makeEmptyContainerName(containerId: string): string;
     /**
      *
      * @param {string} containerId - The id of the container to make unique
      * @param {string} newName - The new name to make unique
-     * @param {never} _legacyContainerType - do not use, has no effect. Is deprecated and will be removed in v.17
-     * @param {never} _legacyParentId - do not use, has no effect. Is deprecated and will be removed in v.17
      * @returns
      */
-    makeContainerNameUniqueForOwnerContentType(containerId: string, newName: string, _legacyContainerType?: UmbPropertyContainerTypes, _legacyParentId?: string | null): string | null;
+    makeContainerNameUniqueForOwnerContentType(containerId: string, newName: string): string | null;
     updateContainer(contentTypeUnique: string | null, containerId: string, partialUpdate: Partial<UmbPropertyTypeContainerModel>): Promise<void>;
     removeContainer(contentTypeUnique: string | null, containerId?: string | null, args?: {
         preventRemovingProperties?: boolean;
@@ -150,14 +149,17 @@ export declare class UmbContentTypeStructureManager<T extends UmbContentTypeMode
      * @returns {Observable} - An observable that emits the merged containers that match the provided container ids.
      */
     /**
-     *
-     * Find merged containers that match the provided container ids.
-     * Notice if you can provide one or more ids matching the same container and it will still only return return the matching container once.
-     * @param containerIds - An array of container ids to find merged containers for.
-     * @param id
+     * Find a merged container that match the provided container id.
+     * @param {string} id - The id to find the merged container of.
      * @returns {UmbPropertyTypeContainerMergedModel | undefined} - The merged containers that match the provided container ids.
      */
     getMergedContainerById(id: string): UmbPropertyTypeContainerMergedModel | undefined;
+    /**
+     * Find a merged container that match the provided merged-container key.
+     * @param {string} key - The key to find the merged container of.
+     * @returns {UmbPropertyTypeContainerMergedModel | undefined} - The merged containers that match the provided merged-container key.
+     */
+    getMergedContainerByKey(key: string): UmbPropertyTypeContainerMergedModel | undefined;
     /**
      *
      * Find merged child containers that are children of the provided parent container ids.

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

@@ -182,6 +182,8 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         this.#ownerContentTypeUnique = unique;
         if (!unique) {
             this.#initRejection?.(`Content Type structure manager could not load: ${unique}`);
+            this.#initResolver = undefined;
+            this.#initRejection = undefined;
             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]);
@@ -189,6 +191,8 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         const result = await this.observe(observable).asPromise();
         if (!result) {
             this.#initRejection?.(`Content Type structure manager could not load: ${unique}`);
+            this.#initResolver = undefined;
+            this.#initRejection = undefined;
             return {
                 error: new UmbError(`Content Type structure manager could not load: ${unique}`),
                 asObservable: () => observable,
@@ -200,9 +204,13 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         }).catch(() => {
             const msg = `Content Type structure manager could not load: ${unique}. Not all Content Types loaded successfully.`;
             this.#initRejection?.(msg);
+            this.#initResolver = undefined;
+            this.#initRejection = undefined;
             return Promise.reject(new UmbError(msg));
         });
         this.#initResolver?.(result);
+        this.#initResolver = undefined;
+        this.#initRejection = undefined;
         return { data: result, asObservable: () => this.ownerContentType };
     }
     async createScaffold(preset) {
@@ -212,6 +220,8 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         const { data } = repsonse;
         if (!data) {
             this.#initRejection?.(`Content Type structure manager could not create scaffold`);
+            this.#initResolver = undefined;
+            this.#initRejection = undefined;
             return { error: repsonse.error };
         }
         this.#ownerContentTypeUnique = data.unique;
@@ -220,6 +230,8 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         // Make a entry in the repo manager:
         this.#repoManager.addEntry(data);
         this.#initResolver?.(data);
+        this.#initResolver = undefined;
+        this.#initRejection = undefined;
         return repsonse;
     }
     /**
@@ -280,6 +292,9 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
     getOwnerContentType() {
         return this.#contentTypes.getValue().find((y) => y.unique === this.#ownerContentTypeUnique);
     }
+    getOwnerContentTypeName() {
+        return this.getOwnerContentType()?.name;
+    }
     getOwnerContentTypeUnique() {
         return this.#ownerContentTypeUnique;
     }
@@ -374,7 +389,7 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
                 const newName = 'Unnamed';
                 this.#editedTypes.appendOne(contentTypeUnique);
                 this.updateContainer(null, container.id, {
-                    name: this.makeContainerNameUniqueForOwnerContentType(container.id, newName, type, parentId) ?? newName,
+                    name: this.makeContainerNameUniqueForOwnerContentType(container.id, newName) ?? newName,
                 });
             }
         });
@@ -420,23 +435,16 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
         this.#contentTypes.updateOne(contentTypeUnique, { containers });
         return newContainer;
     }
-    makeEmptyContainerName(containerId, legacyContainerType, legacyParentId) {
-        return (this.makeContainerNameUniqueForOwnerContentType(containerId, 'Unnamed', legacyContainerType, legacyParentId) ??
-            'Unnamed');
+    makeEmptyContainerName(containerId) {
+        return this.makeContainerNameUniqueForOwnerContentType(containerId, 'Unnamed') ?? 'Unnamed';
     }
     /**
      *
      * @param {string} containerId - The id of the container to make unique
      * @param {string} newName - The new name to make unique
-     * @param {never} _legacyContainerType - do not use, has no effect. Is deprecated and will be removed in v.17
-     * @param {never} _legacyParentId - do not use, has no effect. Is deprecated and will be removed in v.17
      * @returns
      */
-    makeContainerNameUniqueForOwnerContentType(containerId, newName, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _legacyContainerType, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _legacyParentId) {
+    makeContainerNameUniqueForOwnerContentType(containerId, newName) {
         const container = this.getOwnerContainerById(containerId);
         if (!container) {
             console.warn(`Container with id ${containerId} not found in owner content type.`);
@@ -752,16 +760,21 @@ export class UmbContentTypeStructureManager extends UmbControllerBase {
     }
     */
     /**
-     *
-     * Find merged containers that match the provided container ids.
-     * Notice if you can provide one or more ids matching the same container and it will still only return return the matching container once.
-     * @param containerIds - An array of container ids to find merged containers for.
-     * @param id
+     * Find a merged container that match the provided container id.
+     * @param {string} id - The id to find the merged container of.
      * @returns {UmbPropertyTypeContainerMergedModel | undefined} - The merged containers that match the provided container ids.
      */
     getMergedContainerById(id) {
         return this.#mergedContainers.find((x) => x.ids.includes(id));
     }
+    /**
+     * Find a merged container that match the provided merged-container key.
+     * @param {string} key - The key to find the merged container of.
+     * @returns {UmbPropertyTypeContainerMergedModel | undefined} - The merged containers that match the provided merged-container key.
+     */
+    getMergedContainerByKey(key) {
+        return this.#mergedContainers.find((x) => x.key === key);
+    }
     /**
      *
      * Find merged child containers that are children of the provided parent container ids.

package/dist-cms/packages/content/content-type/types.d.ts

@@ -55,13 +55,6 @@ export interface UmbPropertyTypeModel {
     dataType: {
         unique: string;
     };
-    /**
-     * The unique identifier of the property type
-     * @deprecated The id property is deprecated and will be removed in version 17. Please use the unique property instead.
-     * @type {string}
-     * @memberof UmbPropertyTypeModel
-     */
-    id: string;
     unique: string;
     container?: {
         id: string;

package/dist-cms/packages/content/content-type/workspace/content-type-workspace-context-base.js

@@ -37,6 +37,7 @@ export class UmbContentTypeWorkspaceContextBase extends UmbEntityDetailWorkspace
         this._getDataPromise = request;
         let { data } = await request;
         if (data) {
+            data = await this._processIncomingData(data);
             data = await this._scaffoldProcessData(data);
             if (this.modalContext) {
                 // Notice if the preset comes with values, they will overwrite the scaffolded values... [NL]

package/dist-cms/packages/content/content-type/workspace/views/design/content-type-design-editor-group.element.js

@@ -237,12 +237,11 @@ let UmbContentTypeWorkspaceViewEditGroupElement = class UmbContentTypeWorkspaceV
 				display: flex;
 				align-items: center;
 				justify-content: space-between;
-				cursor: grab;
 				padding: var(--uui-size-space-4) var(--uui-size-space-5);
 			}
 
-			:host([inherited]) div[slot='header'] {
-				cursor: default;
+			:host([has-owner-container]) div[slot='header'] {
+				cursor: grab;
 			}
 
 			div[slot='header'] > div {
@@ -287,7 +286,7 @@ __decorate([
     state()
 ], UmbContentTypeWorkspaceViewEditGroupElement.prototype, "_groupId", void 0);
 __decorate([
-    state()
+    property({ type: Boolean, reflect: true, attribute: 'has-owner-container' })
 ], UmbContentTypeWorkspaceViewEditGroupElement.prototype, "_hasOwnerContainer", void 0);
 __decorate([
     property({ type: Boolean, reflect: true, attribute: 'inherited' })