@umbraco-cms/backoffice 17.1.0-rc → 17.1.0

package/dist-cms/packages/content/content/workspace/content-detail-workspace-base.d.ts

@@ -75,6 +75,7 @@ export declare abstract class UmbContentDetailWorkspaceContextBase<DetailModelTy
      * @internal
      */
     readonly languages: Observable<UmbLanguageDetailModel[]>;
+    getLanguages(): Array<UmbLanguageDetailModel>;
     protected readonly _segments: UmbArrayState<UmbSegmentModel, unknown>;
     readonly variantOptions: Observable<VariantOptionModelType[]>;
     protected _variantOptionsFilter: (variantOption: VariantOptionModelType) => boolean;
@@ -235,10 +236,5 @@ export declare abstract class UmbContentDetailWorkspaceContextBase<DetailModelTy
     resetState(): void;
     abstract getContentTypeUnique(): string | undefined;
     abstract createPropertyDatasetContext(host: UmbControllerHost, variantId: UmbVariantId): UmbContentPropertyDatasetContext<DetailModelType, ContentTypeDetailModelType, VariantModelType>;
-    /**
-     * Override reload to process incoming data through the value migration pipeline.
-     * This ensures property values are properly transformed when variation settings change.
-     */
-    reload(): Promise<void>;
     destroy(): void;
 }

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

@@ -3,6 +3,7 @@ import { UmbContentWorkspaceDataManager } from '../manager/index.js';
 import { UmbMergeContentVariantDataController } from '../controller/merge-content-variant-data.controller.js';
 import { UmbContentDetailValidationPathTranslator } from './content-detail-validation-path-translator.js';
 import { UmbContentValidationToHintsManager } from './content-validation-to-hints.manager.js';
+import { UmbContentDetailWorkspaceTypeTransformController } from './content-detail-workspace-type-transform.controller.js';
 import { appendToFrozenArray, mergeObservables, observeMultiple, UmbArrayState, } from '../../../../libs/observable-api/index.js';
 import { firstValueFrom, map } from '../../../../external/rxjs/index.js';
 import { umbOpenModal } from '../../../core/modal/index.js';
@@ -43,6 +44,9 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
     // TODO: Optimize this so it uses either a App Language Context? [NL]
     #languageRepository;
     #languages;
+    getLanguages() {
+        return this.#languages.getValue();
+    }
     #variantValidationContexts;
     getVariantValidationContext(variantId) {
         return this.#variantValidationContexts.find((x) => x.getVariantId()?.compare(variantId));
@@ -54,11 +58,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
     #validationRepository;
     #saveModalToken;
     #contentTypePropertyName;
-    /**
-     * Cache of property variation settings to detect changes when structure is updated.
-     * Used to trigger value migration when properties change from invariant to variant or vice versa.
-     */
-    #propertyVariationCache;
     constructor(host, args) {
         super(host, args);
         this.IS_CONTENT_WORKSPACE_CONTEXT = true;
@@ -93,11 +92,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this._variantOptionsFilter = (variantOption) => true;
         this.#variantValidationContexts = [];
         this.#serverValidation = new UmbServerModelValidatorContext(this);
-        /**
-         * Cache of property variation settings to detect changes when structure is updated.
-         * Used to trigger value migration when properties change from invariant to variant or vice versa.
-         */
-        this.#propertyVariationCache = new Map();
         this.finishPropertyValueChange = () => {
             this._data.finishPropertyValueChange();
         };
@@ -120,6 +114,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);
+        new UmbContentDetailWorkspaceTypeTransformController(this);
         this.variantOptions = mergeObservables([this.variesByCulture, this.variesBySegment, this.variants, this.languages, this._segments.asObservable()], ([variesByCulture, variesBySegment, variants, languages, segments]) => {
             if ((variesByCulture || variesBySegment) === undefined) {
                 return [];
@@ -235,11 +230,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.observe(this.structure.contentTypeDataTypeUniques, (dataTypeUniques) => {
             this.#dataTypeItemManager.setUniques(dataTypeUniques);
         }, null);
-        // Observe property variation changes to trigger value migration when properties change
-        // from invariant to variant (or vice versa) via Infinite Editing
-        this.observe(this.structure.contentTypeProperties, (properties) => {
-            this.#handlePropertyVariationChanges(properties);
-        }, null);
         this.loadLanguages();
     }
     async loadLanguages() {
@@ -804,61 +794,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.propertyViewGuard.fallbackToPermitted();
         this.propertyWriteGuard.fallbackToPermitted();
     }
-    /**
-     * Handles property variation changes when the document type is updated via Infinite Editing.
-     * When a property's variation setting changes (e.g., from shared/invariant to variant or vice versa),
-     * this method reloads the document to get properly migrated values from the server.
-     */
-    #handlePropertyVariationChanges(properties) {
-        // Skip if no current data or if this is initial load
-        const currentData = this._data.getCurrent();
-        if (!currentData || this.#propertyVariationCache.size === 0) {
-            // Initial load - just populate the cache
-            for (const property of properties) {
-                this.#propertyVariationCache.set(property.alias, {
-                    variesByCulture: property.variesByCulture,
-                    variesBySegment: property.variesBySegment,
-                });
-            }
-            return;
-        }
-        // Check for variation setting changes
-        let hasChanges = false;
-        for (const property of properties) {
-            const cached = this.#propertyVariationCache.get(property.alias);
-            if (cached) {
-                if (cached.variesByCulture !== property.variesByCulture ||
-                    cached.variesBySegment !== property.variesBySegment) {
-                    hasChanges = true;
-                }
-            }
-            // Update cache
-            this.#propertyVariationCache.set(property.alias, {
-                variesByCulture: property.variesByCulture,
-                variesBySegment: property.variesBySegment,
-            });
-        }
-        // If variation settings changed, reload to get properly migrated values
-        if (hasChanges) {
-            this.reload();
-        }
-    }
-    /**
-     * Override reload to process incoming data through the value migration pipeline.
-     * This ensures property values are properly transformed when variation settings change.
-     */
-    async reload() {
-        const unique = this.getUnique();
-        if (!unique)
-            throw new Error('Unique is not set');
-        const { data } = await this._detailRepository.requestByUnique(unique);
-        if (data) {
-            // Process the data through _processIncomingData to handle value migration
-            const processedData = await this._processIncomingData(data);
-            this._data.setPersisted(processedData);
-            this._data.setCurrent(processedData);
-        }
-    }
     destroy() {
         this.structure.destroy();
         this.#languageRepository.destroy();

package/dist-cms/packages/content/content/workspace/content-detail-workspace-type-transform.controller.d.ts

@@ -0,0 +1,12 @@
+import type { UmbContentDetailModel } from '../index.js';
+import type { UmbContentDetailWorkspaceContextBase } from './content-detail-workspace-base.js';
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import type { UmbEntityVariantModel } from '../../../core/variant/index.js';
+/**
+ * @class UmbContentDetailWorkspaceTypeTransformController
+ * @description - Controller to handle content detail workspace type transformations, such as property variation changes.
+ */
+export declare class UmbContentDetailWorkspaceTypeTransformController<DetailModelType extends UmbContentDetailModel<UmbEntityVariantModel>> extends UmbControllerBase {
+    #private;
+    constructor(host: UmbContentDetailWorkspaceContextBase<DetailModelType, any, any, any>);
+}

package/dist-cms/packages/content/content/workspace/content-detail-workspace-type-transform.controller.js

@@ -0,0 +1,72 @@
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+/**
+ * @class UmbContentDetailWorkspaceTypeTransformController
+ * @description - Controller to handle content detail workspace type transformations, such as property variation changes.
+ */
+export class UmbContentDetailWorkspaceTypeTransformController extends UmbControllerBase {
+    #workspace;
+    // Current property types, currently used to detect variation changes:
+    #propertyTypes;
+    constructor(host) {
+        super(host);
+        this.#workspace = host;
+        // Observe property variation changes to trigger value migration when properties change
+        // from invariant to variant (or vice versa) via Infinite Editing
+        this.observe(host.structure.contentTypeProperties, (propertyTypes) => {
+            this.#handlePropertyTypeVariationChanges(this.#propertyTypes, propertyTypes);
+            this.#propertyTypes = propertyTypes;
+        }, null);
+    }
+    async #handlePropertyTypeVariationChanges(oldPropertyTypes, newPropertyTypes) {
+        if (!oldPropertyTypes || !newPropertyTypes) {
+            return;
+        }
+        // Skip if no current data or if this is initial load
+        const currentData = this.#workspace.getData();
+        if (!currentData) {
+            return;
+        }
+        const defaultLanguage = this.#getDefaultLanguage();
+        // To spare a bit of energy we keep awareness of whether this brings any changes:
+        let hasChanges = false;
+        const values = currentData.values.map((v) => {
+            const transformation = this.#transformValueForVariationChange(v, oldPropertyTypes, newPropertyTypes, defaultLanguage);
+            if (transformation.changed) {
+                hasChanges = true;
+            }
+            return transformation.value;
+        });
+        if (hasChanges) {
+            this.#workspace.setData({ ...currentData, values });
+        }
+    }
+    #getDefaultLanguage() {
+        const languages = this.#workspace.getLanguages();
+        const defaultLanguage = languages.find((lang) => lang.isDefault)?.unique;
+        if (!defaultLanguage) {
+            throw new Error('Default language not found');
+        }
+        return defaultLanguage;
+    }
+    #transformValueForVariationChange(value, oldPropertyTypes, newPropertyTypes, defaultLanguage) {
+        const oldType = oldPropertyTypes.find((p) => p.alias === value.alias);
+        const newType = newPropertyTypes.find((p) => p.alias === value.alias);
+        // If we cant find both, we do not dare changing anything. Notice a composition may not have been loaded yet.
+        if (!oldType || !newType) {
+            return { value, changed: false };
+        }
+        // If variation hasn't changed, return unchanged
+        if (oldType.variesByCulture === newType.variesByCulture) {
+            return { value, changed: false };
+        }
+        // Variation has changed, migrate the value
+        if (newType.variesByCulture) {
+            // If it now varies by culture, set to default language
+            return { value: { ...value, culture: defaultLanguage }, changed: true };
+        }
+        else {
+            // If it no longer varies by culture, set to invariant
+            return { value: { ...value, culture: null }, changed: true };
+        }
+    }
+}

package/dist-cms/packages/core/property/property-value-preset/property-value-preset-variant-builder.controller.js

@@ -72,42 +72,14 @@ export class UmbPropertyValuePresetVariantBuilderController extends UmbPropertyV
         };
         return args;
     }
-    /**
-     * Finds an existing value for a property, with fallback logic for variation setting changes.
-     * When a property changes from invariant to variant (or vice versa), the existing values
-     * may have a different culture/segment than what we're looking for. This method handles
-     * value migration by trying fallback lookups.
-     */
     #findExistingValue(alias, variantId) {
-        if (!this._existingValues)
+        if (!this._existingValues) {
             return undefined;
-        // First, try exact match (same alias + same culture/segment)
+        }
         const exactMatch = this._existingValues.find((x) => x.alias === alias && variantId.compare(x));
         if (exactMatch) {
             return exactMatch.value;
         }
-        // No exact match - try fallback for variation setting changes
-        // Get all values for this property alias
-        const valuesForAlias = this._existingValues.filter((x) => x.alias === alias);
-        if (valuesForAlias.length === 0) {
-            return undefined;
-        }
-        // Fallback 1: If looking for a culture-specific value, try to use the invariant value
-        // This handles: invariant → variant migration
-        if (variantId.culture !== null) {
-            const invariantValue = valuesForAlias.find((x) => x.culture === null && x.segment === variantId.segment);
-            if (invariantValue) {
-                return invariantValue.value;
-            }
-        }
-        // Fallback 2: If looking for an invariant value, try to use the first culture-specific value
-        // This handles: variant → invariant migration
-        if (variantId.culture === null) {
-            const anyVariantValue = valuesForAlias.find((x) => x.culture !== null && x.segment === variantId.segment);
-            if (anyVariantValue) {
-                return anyVariantValue.value;
-            }
-        }
         return undefined;
     }
 }

package/dist-cms/packages/core/workspace/entity-detail/entity-detail-workspace-base.d.ts

@@ -62,6 +62,11 @@ export declare abstract class UmbEntityDetailWorkspaceContextBase<DetailModelTyp
      * @returns { DetailModelType | undefined } The entity context
      */
     getData(): DetailModelType | undefined;
+    /**
+     * Get the current data
+     * @param {DetailModelType | undefined} data - New data of this workspace.
+     */
+    setData(data: DetailModelType | undefined): void;
     /**
      * Get the persisted data
      * @returns { DetailModelType | undefined } The persisted data

package/dist-cms/packages/core/workspace/entity-detail/entity-detail-workspace-base.js

@@ -145,6 +145,13 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
     getData() {
         return this._data.getCurrent();
     }
+    /**
+     * Get the current data
+     * @param {DetailModelType | undefined} data - New data of this workspace.
+     */
+    setData(data) {
+        this._data.setCurrent(data);
+    }
     /**
      * Get the persisted data
      * @returns { DetailModelType | undefined } The persisted data
@@ -231,7 +238,7 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
             }
         }
         else if (data) {
-            const processedData = await this._scaffoldProcessData(data);
+            const processedData = await this._processIncomingData(data);
             this._data.setPersisted(processedData);
             this._data.setCurrent(processedData);
             this.observe(asObservable?.(), (entity) => this.#onDetailStoreChange(entity), 'umbEntityDetailTypeStoreObserver');
@@ -249,8 +256,9 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
             throw new Error('Unique is not set');
         const { data } = await this._detailRepository.requestByUnique(unique);
         if (data) {
-            this._data.setPersisted(data);
-            this._data.setCurrent(data);
+            const processedData = await this._processIncomingData(data);
+            this._data.setPersisted(processedData);
+            this._data.setCurrent(processedData);
         }
     }
     /**