@umbraco-cms/backoffice 18.3.0-rc2 → 19.0.0-beta1

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

@@ -1,20 +1,24 @@
 import { UmbContentCollectionConfigurationContext, UmbContentCollectionManager } from '../collection/index.js';
 import { UmbContentWorkspaceDataManager } from '../manager/index.js';
 import { UmbMergeContentVariantDataController } from '../controller/merge-content-variant-data.controller.js';
+import { UmbEntryDataValueVariantsController } from '../controller/entry-data-value-variants.controller.js';
+import { umbEntryAppendValue } from '../utils/index.js';
+import { _resolveIsWritableVariant } from './content-writable-variant.function.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 { UmbContentTypeVarianceChangeRedirectController } from './content-type-variance-change-redirect.controller.js';
+import { mergeObservables, observeMultiple, UmbArrayState } from '../../../../libs/observable-api/index.js';
+import { combineLatest, distinctUntilChanged, filter, firstValueFrom, map, } from '../../../../external/rxjs/index.js';
 import { umbOpenModal } from '../../../core/modal/index.js';
 import { UmbContentTypeStructureManager } from '../../content-type/index.js';
 import { UmbDataTypeItemRepositoryManager } from '../../../data-type/index.js';
 import { UmbDeprecation, UmbReadOnlyVariantGuardManager } from '../../../core/utils/index.js';
-import { notifyWorkspaceActionStarting, UmbEntityDetailWorkspaceContextBase, UmbWorkspaceSplitViewManager, } from '../../../core/workspace/index.js';
+import { notifyWorkspaceActionStarting, UmbEntityDetailWorkspaceContextBase, UmbVariantNameWriteGuardManager, UmbWorkspaceSplitViewManager, UmbWorkspaceVariantOptionsController, } from '../../../core/workspace/index.js';
 import { UmbEntityUpdatedEvent, UmbRequestReloadChildrenOfEntityEvent, UmbRequestReloadStructureForEntityEvent, } from '../../../core/entity-action/index.js';
 import { UMB_APP_LANGUAGE_CONTEXT } from '../../../language/index.js';
-import { UmbPropertyValueFlatMapperController, UmbPropertyValuePresetVariantBuilderController, UmbVariantPropertyGuardManager, } from '../../../core/property/index.js';
-import { UmbVariantId } from '../../../core/variant/index.js';
+import { UmbPropertyValuePresetVariantBuilderController, UmbVariantPropertyGuardManager, } from '../../../core/property/index.js';
+import { UmbVariantId, umbExpandVariantIdsWithSegmentOptions } from '../../../core/variant/index.js';
 import { UMB_ACTION_EVENT_CONTEXT } from '../../../core/action/index.js';
 import { UMB_VALIDATION_EMPTY_LOCALIZATION_KEY, UmbDataPathVariantQuery, UmbServerModelValidatorContext, UmbValidationCleanUpByUniqueManager, UmbValidationController, } from '../../../core/validation/index.js';
 /**
@@ -41,13 +45,30 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
     #variesByCulture;
     #variesBySegment;
     #collectionConfiguration;
-    /* Variant Options */
-    #languages;
+    /**
+     * @deprecated - Use the languages observable from the variant options manager instead.
+     * @example
+     * ```ts
+     * const languages = contentDetailWorkspace.variantOptionsManager.getLanguages();
+     * ```
+     */
     getLanguages() {
-        return this.#languages.getValue();
+        new UmbDeprecation({
+            deprecated: 'Workspace `getLanguages()` is deprecated.',
+            removeInVersion: '21.0.0',
+            solution: 'Use `variantOptionsManager.getLanguages()` instead.',
+        }).warn();
+        return this.variantOptionsManager.getLanguages();
     }
+    /**
+     * Resolves with the variant options once they have loaded.
+     * @returns {Promise<Array<VariantOptionModelType>>} The loaded variant options.
+     */
     async getVariantOptions() {
-        return firstValueFrom(this.variantOptions);
+        return firstValueFrom(this.variantOptions.pipe(filter((options) => options !== undefined)));
+    }
+    async getCultureVariantOptions() {
+        return (await this.getVariantOptions()).filter((x) => !x.segment);
     }
     #variantValidationContexts;
     getVariantValidationContext(variantId) {
@@ -64,6 +85,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         super(host, args);
         this.IS_CONTENT_WORKSPACE_CONTEXT = true;
         this.readOnlyGuard = new UmbReadOnlyVariantGuardManager(this);
+        this.nameWriteGuard = new UmbVariantNameWriteGuardManager(this);
         this.propertyViewGuard = new UmbVariantPropertyGuardManager(this);
         this.propertyWriteGuard = new UmbVariantPropertyGuardManager(this);
         /* Content Data */
@@ -72,6 +94,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.values = this._data.createObservablePartOfCurrent((data) => data?.values);
         this.variants = this._data.createObservablePartOfCurrent((data) => data?.variants ?? []);
         this.persistedData = this._data.persisted;
+        this.valueVariants = new UmbEntryDataValueVariantsController(this, this._data);
         /* Data Type */
         // This dataTypeItemManager is used to load the data type items for this content type, so we have all data-types for this content type up front. [NL]
         // But once we have a proper application cache this could be solved in a way where we ask the cache for the data type items. [NL]
@@ -80,27 +103,25 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         /* Split View */
         this.splitView = new UmbWorkspaceSplitViewManager();
         this.#collectionConfiguration = new UmbContentCollectionConfigurationContext(this);
-        /* Variant Options */
-        this.#languages = new UmbArrayState([], (x) => x.unique);
+        // TODO: Remove this property in v.21
         /**
-         * @private
-         * @description - Should not be used by external code.
-         * @internal
+         * This property is deprecated and will be removed in v.21.
+         * @deprecated Deprecated since v19. It is not possible to filter variant options from v21. Will be removed in v21.
          */
-        this.languages = this.#languages.asObservable();
-        this._segments = new UmbArrayState([], (x) => x.alias);
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        this._variantOptionsFilter = (variantOption) => true;
+        this._variantOptionsFilter = (_variantOption) => true;
         this.#variantValidationContexts = [];
         this.#serverValidation = new UmbServerModelValidatorContext(this);
         this.finishPropertyValueChange = () => {
             this._data.finishPropertyValueChange();
         };
         this._saveableVariantsFilter = (option) => {
-            return this.readOnlyGuard.getIsPermittedForVariant(UmbVariantId.Create(option)) === false;
+            return this.getIsWritableVariant(UmbVariantId.Create(option));
         };
+        this.#writableVariantProperties = [];
+        this.#writableVariantOptions = [];
         this.propertyViewGuard.fallbackToPermitted();
         this.propertyWriteGuard.fallbackToPermitted();
+        this.nameWriteGuard.fallbackToPermitted();
         this.#serverValidation.addPathTranslator(UmbContentDetailValidationPathTranslator);
         this._data.setVariantScaffold(args.contentVariantScaffold);
         this.#saveModalToken = args.saveModalToken;
@@ -110,96 +131,42 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.#validateOnSubmit = args.skipValidationOnSubmit ? !args.skipValidationOnSubmit : true;
         this.#ignoreValidationResultOnSubmit = args.ignoreValidationResultOnSubmit ?? false;
         this.structure = new UmbContentTypeStructureManager(this, contentTypeDetailRepository);
-        this.variesByCulture = this.structure.ownerContentTypeObservablePart((x) => x?.variesByCulture);
-        this.variesBySegment = this.structure.ownerContentTypeObservablePart((x) => x?.variesBySegment);
+        this.variesByCulture = this.structure.variesByCulture;
+        this.variesBySegment = this.structure.variesBySegment;
         this.varies = this.structure.ownerContentTypeObservablePart((x) => x ? x.variesByCulture || x.variesBySegment : undefined);
+        // Languages are requested once per app session by UMB_APP_LANGUAGE_CONTEXT; every workspace observes
+        // that shared state instead of each issuing its own request for the full language collection.
+        const appLanguages = new UmbArrayState(undefined, (x) => x.unique);
+        this.consumeContext(UMB_APP_LANGUAGE_CONTEXT, (appLanguageContext) => {
+            this.observe(appLanguageContext?.languages, (languages) => appLanguages.setValue(languages), null);
+        });
+        this.variantOptionsManager = new UmbWorkspaceVariantOptionsController(this, this.variesByCulture, this.variesBySegment, this.variants, appLanguages.asObservable());
+        const defaultVariantOptionsFilter = this._variantOptionsFilter;
+        let hasWarnedVariantOptionsFilter = false;
+        this.variantOptionsManager._internal_setOptionFilter((option) => {
+            if (!hasWarnedVariantOptionsFilter && this._variantOptionsFilter !== defaultVariantOptionsFilter) {
+                hasWarnedVariantOptionsFilter = true;
+                new UmbDeprecation({
+                    deprecated: '_variantOptionsFilter',
+                    removeInVersion: '21.0.0',
+                    solution: 'Filtering variant options is no longer supported.',
+                }).warn();
+            }
+            return this._variantOptionsFilter(option);
+        });
+        this.variantOptions = this.variantOptionsManager.variantOptions;
+        this.languages = this.variantOptionsManager.languages;
+        this.observe(this.variantOptions, (variantOptions) => (this.#writableVariantOptions = variantOptions ?? []), null);
+        this.observe(this.structure.contentTypeProperties, (properties) => (this.#writableVariantProperties = properties), null);
         this.#collectionConfiguration.setCollectionAlias(args.collectionAlias);
         this.observe(this.structure.ownerContentTypeObservablePart((x) => x?.collection?.unique), (dataTypeUnique) => this.#collectionConfiguration.setDataTypeUnique(dataTypeUnique ?? undefined), null);
         this.observe(this.unique, (unique) => this.#collectionConfiguration.setUnique(unique ?? null), null);
         this.collection = new UmbContentCollectionManager(this, this.structure, args.collectionAlias);
         new UmbContentValidationToHintsManager(this, this.structure, this.validationContext, this.view.hints);
         new UmbContentDetailWorkspaceTypeTransformController(this, this._data);
-        this.variantOptions = mergeObservables([this.variesByCulture, this.variesBySegment, this.variants, this.languages, this._segments.asObservable()], ([variesByCulture, variesBySegment, variants, languages, segments]) => {
-            if ((variesByCulture || variesBySegment) === undefined) {
-                return [];
-            }
-            const varies = variesByCulture || variesBySegment;
-            // No variation
-            if (!varies) {
-                return [
-                    {
-                        variant: variants.find((x) => new UmbVariantId(x.culture, x.segment).isInvariant()),
-                        language: languages.find((x) => x.isDefault),
-                        culture: null,
-                        segment: null,
-                        unique: new UmbVariantId().toString(),
-                    },
-                ];
-            }
-            // Only culture variation
-            if (variesByCulture && !variesBySegment) {
-                return languages.map((language) => {
-                    return {
-                        variant: variants.find((x) => x.culture === language.unique),
-                        language,
-                        culture: language.unique,
-                        segment: null,
-                        unique: new UmbVariantId(language.unique).toString(),
-                    };
-                });
-            }
-            // Only segment variation
-            if (!variesByCulture && variesBySegment) {
-                const invariantCulture = {
-                    variant: variants.find((x) => new UmbVariantId(x.culture, x.segment).isInvariant()),
-                    language: languages.find((x) => x.isDefault),
-                    culture: null,
-                    segment: null,
-                    unique: new UmbVariantId().toString(),
-                };
-                // 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.alias),
-                        language: languages.find((x) => x.isDefault),
-                        segmentInfo: segment,
-                        culture: null,
-                        segment: segment.alias,
-                        unique: new UmbVariantId(null, segment.alias).toString(),
-                    };
-                });
-                return [invariantCulture, ...segmentsForInvariantCulture];
-            }
-            // Culture and segment variation
-            if (variesByCulture && variesBySegment) {
-                return languages.flatMap((language) => {
-                    const culture = {
-                        variant: variants.find((x) => x.culture === language.unique && x.segment === null),
-                        language,
-                        culture: language.unique,
-                        segment: null,
-                        unique: new UmbVariantId(language.unique).toString(),
-                    };
-                    // 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.alias),
-                            language,
-                            segmentInfo: segment,
-                            culture: language.unique,
-                            segment: segment.alias,
-                            unique: new UmbVariantId(language.unique, segment.alias).toString(),
-                        };
-                    });
-                    return [culture, ...segmentsForCulture];
-                });
-            }
-            return [];
-        }).pipe(map((options) => options.filter((option) => this._variantOptionsFilter(option))));
+        this.contentTypeVarianceChangeRedirect = new UmbContentTypeVarianceChangeRedirectController(this);
         this.observe(this.variantOptions, (variantOptions) => {
-            variantOptions.forEach((variantOption) => {
+            variantOptions?.forEach((variantOption) => {
                 const missingThis = !this.#variantValidationContexts.some((x) => {
                     const variantId = x.getVariantId();
                     if (!variantId)
@@ -226,8 +193,11 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
                 return undefined;
             return aliases;
         }), (queryParams) => queryParams.alias);
+        this.observe(this.valueVariants.variants, (variants) => {
+            this.#ensureVariantEntriesOf(variants);
+        }, null);
         this.observe(observeMultiple([this.splitView.activeVariantByIndex(0), this.variants]), ([activeVariant, variants]) => {
-            const variantName = variants.find((v) => v.culture === activeVariant?.culture && v.segment === activeVariant?.segment)?.name;
+            const variantName = variants.find((v) => v.culture === activeVariant?.culture)?.name;
             this.view.setTitle(variantName);
         }, null);
         this.observe(this.varies, (varies) => {
@@ -245,11 +215,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.observe(this.structure.contentTypeDataTypeUniques, (dataTypeUniques) => {
             this.#dataTypeItemManager.setUniques(dataTypeUniques);
         }, null);
-        // Languages are requested once per app session by UMB_APP_LANGUAGE_CONTEXT; every workspace observes
-        // that shared state instead of each issuing its own request for the full language collection.
-        this.consumeContext(UMB_APP_LANGUAGE_CONTEXT, (appLanguageContext) => {
-            this.observe(appLanguageContext?.languages, (languages) => this.#languages.setValue(languages ?? []), null);
-        });
     }
     /**
      * @deprecated No need to call loadLanguages, will be removed in v.20.
@@ -261,25 +226,20 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             solution: 'No need to call loadLanguages.',
         }).warn();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async _loadSegmentsFor(unique) {
-        console.warn(`UmbContentDetailWorkspaceContextBase: Segments are not implemented in the workspace context for "${this.getEntityType()}" types.`);
-        this._segments.setValue([]);
-    }
     async _processIncomingData(data) {
+        // TODO: replace with contentType when it gets implemented for content detail model [NL]
         const contentTypeUnique = data[this.#contentTypePropertyName].unique;
         if (!contentTypeUnique) {
             throw new Error(`Could not find content type unique on property '${this.#contentTypePropertyName}'`);
         }
+        const incoming = this.incomingDataHook.execute({
+            entityType: this.getEntityType(),
+            unique: data.unique,
+            contentType: contentTypeUnique ? { unique: contentTypeUnique } : undefined,
+        });
         // 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);
-        // Load segments if varying by segment, or reset to empty array:
-        if (this.#variesBySegment) {
-            await this._loadSegmentsFor(data.unique);
-        }
-        else {
-            this._segments.setValue([]);
-        }
+        const loadType = this.structure.loadType(contentTypeUnique);
+        await Promise.all([incoming, loadType]);
         const propertyTypes = await this.structure.getContentTypeProperties();
         const contentTypeVariesByCulture = this.structure.getVariesByCulture();
         const contentTypeVariesBySegment = this.structure.getVariesBySegment();
@@ -302,7 +262,8 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             };
         }));
         const controller = new UmbPropertyValuePresetVariantBuilderController(this);
-        const variantOptions = (await firstValueFrom(this.variantOptions)).map((o) => new UmbVariantId(o.culture, o.segment));
+        // TODO: Let´s make sure we have all the various variant options available at this point... [NL]
+        const variantOptions = (await this.getVariantOptions()).map((o) => new UmbVariantId(o.culture, o.segment));
         if (contentTypeVariesByCulture) {
             variantOptions.push(UmbVariantId.CreateInvariant()); // Ensure invariant is included, when the contentType varies by culture, because we do not have a invariant-variant in our variant-options. [NL]
         }
@@ -345,16 +306,18 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         if (!variants)
             return;
         if (variantId) {
-            return variants.find((x) => variantId.compare(x))?.name;
+            return variants.find((x) => variantId.culture === x.culture)?.name;
         }
         // Get the first active variant's name
         const activeVariant = this.splitView.getActiveVariants()[0];
         if (activeVariant) {
-            const activeVariantId = UmbVariantId.Create(activeVariant);
-            return variants.find((x) => activeVariantId.compare(x))?.name;
+            return variants.find((x) => activeVariant.culture === x.culture)?.name;
+        }
+        // Fallback to first variant if no active variant is set. [NL]
+        if (variants[0]) {
+            return variants[0].name;
         }
-        // Fallback to first variant if no active variant is set
-        return variants[0]?.name;
+        return undefined;
     }
     /**
      * Set the name of a variant
@@ -374,14 +337,13 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
     name(variantId) {
         if (variantId) {
             // Explicit variant requested
-            return this._data.createObservablePartOfCurrent((data) => data?.variants?.find((x) => variantId.compare(x))?.name ?? '');
+            return this._data.createObservablePartOfCurrent((data) => data?.variants?.find((x) => x.culture === variantId.culture)?.name ?? '');
         }
         // No variant specified - observe first active variant's name
         return mergeObservables([this.splitView.activeVariantByIndex(0), this.variants], ([activeVariant, variants]) => {
             if (!activeVariant || !variants)
                 return '';
-            const activeVariantId = UmbVariantId.Create(activeVariant);
-            return variants.find((x) => activeVariantId.compare(x))?.name ?? '';
+            return variants.find((x) => x.culture === activeVariant.culture)?.name ?? '';
         });
     }
     /* Variants */
@@ -416,7 +378,11 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
      * @memberof UmbContentDetailWorkspaceContextBase
      */
     variantById(variantId) {
-        return this._data.createObservablePartOfCurrent((data) => data?.variants?.find((x) => variantId.compare(x)));
+        if (variantId.segment) {
+            // Segments cannot have a variant-data, so we return undefined for them. [NL]
+            return this._data.createObservablePartOfCurrent(() => undefined);
+        }
+        return this._data.createObservablePartOfCurrent((data) => data?.variants?.find((x) => variantId.culture === x.culture));
     }
     /**
      * Get the variant by the given variantId
@@ -425,7 +391,11 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
      * @memberof UmbContentDetailWorkspaceContextBase
      */
     getVariant(variantId) {
-        return this._data.getCurrent()?.variants?.find((x) => variantId.compare(x));
+        if (variantId.segment) {
+            // Segments cannot have a variant-data, so we return undefined for them. [NL]
+            return undefined;
+        }
+        return this._data.getCurrent()?.variants?.find((x) => variantId.culture === x.culture);
     }
     getVariants() {
         return this._data.getCurrent()?.variants;
@@ -442,7 +412,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
     /* Values */
     /**
      * Get the values of the content
-     * @returns {Array<UmbElementValueModel> | undefined} - The values of the content
+     * @returns {Array<UmbEntryValueModel> | undefined} - The values of the content
      * @memberof UmbContentDetailWorkspaceContextBase
      */
     getValues() {
@@ -466,11 +436,11 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
      * @param {UmbVariantId | undefined} variantId - The variant id of the property
      * @returns {ReturnType | undefined} The value or undefined if not set or found.
      */
-    getPropertyValue(alias, variantId) {
+    getPropertyValue(alias, variantId = UmbVariantId.CreateInvariant()) {
         const currentData = this._data.getCurrent();
         if (currentData) {
             // No variantId means invariant: match only entries with culture === null and segment === null.
-            const newDataSet = currentData.values?.find((x) => x.alias === alias && (variantId ?? UmbVariantId.CreateInvariant()).compare(x));
+            const newDataSet = currentData.values?.find((x) => x.alias === alias && variantId.compare(x));
             return newDataSet?.value;
         }
         return undefined;
@@ -483,10 +453,9 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
      * @param {UmbVariantId} [variantId] - The variant id of the property
      * @memberof UmbContentDetailWorkspaceContextBase
      */
-    async setPropertyValue(alias, value, variantId) {
+    async setPropertyValue(alias, value, variantId = UmbVariantId.CreateInvariant()) {
         try {
             this.initiatePropertyValueChange();
-            variantId ??= UmbVariantId.CreateInvariant();
             const property = await this.structure.getPropertyStructureByAlias(alias);
             if (!property) {
                 throw new Error(`Property alias "${alias}" not found.`);
@@ -513,8 +482,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             };
             const currentData = this.getData();
             if (currentData) {
-                const values = appendToFrozenArray(currentData.values ?? [], entry, (x) => x.alias === alias && variantId.compare(x));
-                this.#ensureVariantsExistsForProperty(variantId, entry);
+                const values = umbEntryAppendValue(currentData.values ?? [], entry, (x) => x.alias === alias && variantId.compare(x));
                 this._data.updateCurrent({ values });
             }
         }
@@ -522,48 +490,30 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             this.finishPropertyValueChange();
         }
     }
-    async #ensureVariantsExistsForProperty(variantId, entry) {
-        // TODO: Implement queueing of these operations to ensure this does not execute too often. [NL]
-        const cultureOptions = await this.getVariantOptions();
-        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);
+    /**
+     * Ensure the given variants exist in the data's variants array, if not, add them.
+     * But it should only contain culture-variant entries, as we do not want to create segment-variant entries.
+     * @param {Array<UmbObjectWithVariantProperties>} variants The variants to ensure exist in the data's variants array
+     * @returns {Promise<void>}
+     * @memberof UmbContentDetailWorkspaceContextBase
+     */
+    async #ensureVariantEntriesOf(variants) {
+        const existingVariants = this._data.getCurrent()?.variants ?? [];
+        // Filter variantIds on what is already present:
+        const missingVariants = variants.filter((variantId) => {
+            return !existingVariants.some((v) => variantId.culture === v.culture);
+        });
+        if (missingVariants.length === 0)
+            return;
+        const cultureOptions = await this.getCultureVariantOptions();
+        // Filter away missingVariants that are not part of the cultureOptions:
+        const variantsToUpdate = missingVariants.filter((variant) => {
+            return cultureOptions.some((x) => variant.culture === x.culture);
+        });
+        // ensure variantToUpdate is unique by culture, as we do not want to create multiple entries for the same culture:
+        const uniqueVariantsToUpdate = variantsToUpdate.filter((variant, index, self) => index === self.findIndex((v) => v.culture === variant.culture));
+        // Only create Culture Variant IDs, we only want to have variant entries for the culture
+        this._data.ensureVariantsData(uniqueVariantsToUpdate.map((variant) => new UmbVariantId(variant.culture, null)));
     }
     initiatePropertyValueChange() {
         this._data.initiatePropertyValueChange();
@@ -577,7 +527,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         return this._data.getChangedVariants();
     }
     async _determineVariantOptions() {
-        const options = (await this.getVariantOptions()).filter((option) => option.segment === null);
+        const options = await this.getCultureVariantOptions();
         const activeVariants = this.splitView.getActiveVariants();
         const activeVariantIds = activeVariants.map((activeVariant) => UmbVariantId.Create(activeVariant));
         const changedVariantIds = this._data.getChangedVariants();
@@ -587,7 +537,7 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             .filter((x) => x.segment !== null)
             .map((x) => x.toSegmentInvariant());
         const selectedVariantIds = [...activeAndChangedVariantIds, ...changedParentCultureVariantIds];
-        const writableSelectedVariantIds = selectedVariantIds.filter((x) => this.readOnlyGuard.getIsPermittedForVariant(x) === false);
+        const writableSelectedVariantIds = selectedVariantIds.filter((x) => this.getIsWritableVariant(x));
         // Selected can contain entries that are not part of the options, therefor the modal filters selection based on options.
         const selected = writableSelectedVariantIds
             .map((variantId) => variantId.toString())
@@ -598,6 +548,45 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
             selected: uniqueSelected,
         };
     }
+    #writableVariantProperties;
+    #writableVariantOptions;
+    #resolveIsWritableVariant(variantId, properties, variantOptions) {
+        return _resolveIsWritableVariant({
+            variantId,
+            variantOptions,
+            properties,
+            readOnlyGuard: this.readOnlyGuard,
+            nameWriteGuard: this.nameWriteGuard,
+            propertyWriteGuard: this.propertyWriteGuard,
+        });
+    }
+    /**
+     * Observes if the given variant is writable: it is not read-only, and its own name or one of its own properties may
+     * be written. Invariant (shared) data is the invariant variant: `UmbVariantId.CreateInvariant()`.
+     * @param {UmbVariantId} variantId - The variant to check
+     * @returns {Observable<boolean>} emits true if the variant is writable, and again when the answer changes. Emits false until the variant options are loaded.
+     */
+    isWritableVariant(variantId) {
+        return combineLatest([
+            this.readOnlyGuard.rules,
+            this.readOnlyGuard.fallbackPermitted,
+            this.nameWriteGuard.rules,
+            this.nameWriteGuard.fallbackPermitted,
+            this.propertyWriteGuard.rules,
+            this.propertyWriteGuard.fallbackPermitted,
+            this.structure.contentTypeProperties,
+            this.variantOptions,
+        ]).pipe(map(([, , , , , , properties, variantOptions]) => variantOptions === undefined ? false : this.#resolveIsWritableVariant(variantId, properties, variantOptions)), distinctUntilChanged());
+    }
+    /**
+     * Checks if the given variant is writable. See {@link UmbContentDetailWorkspaceContextBase.isWritableVariant}.
+     * Answers false until the content type structure and the variant options are loaded.
+     * @param {UmbVariantId} variantId - The variant to check
+     * @returns {boolean} true if the variant is writable
+     */
+    getIsWritableVariant(variantId) {
+        return this.#resolveIsWritableVariant(variantId, this.#writableVariantProperties, this.#writableVariantOptions);
+    }
     /* validation */
     /**
      * Run the mandatory validation for the save data
@@ -606,24 +595,26 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
      */
     async runMandatoryValidationForSaveData(saveData, variantIds = []) {
         // Check that the data is valid before we save it.
+        // Filter away segment variants as we do not want to validate them:
+        variantIds = variantIds.filter((variant) => variant.isSegmentInvariant());
         // If we vary by culture then we do not want to validate the invariant variant.
         if (this.getVariesByCulture()) {
             variantIds = variantIds.filter((variant) => !variant.isCultureInvariant());
         }
         const missingVariants = variantIds.filter((variant) => {
-            return !saveData.variants.some((y) => variant.compare(y));
+            return !saveData.variants.some((v) => variant.culture === v.culture);
         });
         if (missingVariants.length > 0) {
             throw new Error('One or more selected variants have not been created');
         }
-        // Check variants have a name:
+        // Check variants have a name (prevents potential segment variants to be taken into account):
         const variantsWithoutAName = saveData.variants.filter((x) => !x.name);
         if (variantsWithoutAName.length > 0) {
             variantsWithoutAName.forEach((variant) => {
                 this.validationContext.messages.addMessage('client', `$.variants[${UmbDataPathVariantQuery(variant)}].name`, UMB_VALIDATION_EMPTY_LOCALIZATION_KEY);
             });
-            throw new Error('All variants must have a name, these variants are missing a name: ' +
-                variantsWithoutAName.map((x) => (x.culture ?? 'invariant') + '_' + (x.segment ?? '')).join(', '));
+            throw new Error('All culture variants must have a name, these cultures are missing a name: ' +
+                variantsWithoutAName.map((x) => x.culture ?? 'invariant').join(', '));
         }
     }
     /**
@@ -690,6 +681,14 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         if (options.length === 0) {
             throw new Error('No variants are available');
         }
+        else if (this.getVariesByCulture() &&
+            options.some(this._saveableVariantsFilter) === false &&
+            this.getIsNew() === false &&
+            this.getIsWritableVariant(UmbVariantId.CreateInvariant())) {
+            // No culture may be saved, but the invariant data may. Saving the invariant variant alone stores the
+            // invariant data and leaves every culture as persisted.
+            variantIds.push(UmbVariantId.CreateInvariant());
+        }
         else if (options.length === 1) {
             // If only one option we will skip ahead and save the content with the only variant available:
             variantIds.push(UmbVariantId.Create(options[0]));
@@ -716,6 +715,9 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         }
         // User has committed to saving (modal closed with a selection, or no modal needed).
         notifyWorkspaceActionStarting(executionOptions);
+        if (this.getVariesBySegment()) {
+            variantIds = umbExpandVariantIdsWithSegmentOptions(variantIds, await this.getVariantOptions());
+        }
         const saveData = await this.constructSaveData(variantIds);
         await this.runMandatoryValidationForSaveData(saveData, variantIds);
         if (this.#validateOnSubmit) {
@@ -737,25 +739,6 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         return this._validateByAndSubmit(() => this._validateVariantsAndLog(variantIds), onValid, onInvalid);
     }
     async _validateVariantsAndLog(variantIds) {
-        // Make sure that each variant-id for a given culture, has gotten all the valid segment variant-ids present too. See variant-options for which are available. [NL]
-        if (variantIds && this.getVariesBySegment()) {
-            const variantOptions = await this.getVariantOptions();
-            const expandedVariantIds = [];
-            for (const variantId of variantIds) {
-                // If a culture variant without segment, add all segment variants for that culture:
-                if (variantId.culture !== null && variantId.segment === null) {
-                    for (const option of variantOptions) {
-                        if (option.culture === variantId.culture) {
-                            expandedVariantIds.push(UmbVariantId.Create(option));
-                        }
-                    }
-                }
-                else {
-                    expandedVariantIds.push(variantId);
-                }
-            }
-            variantIds = expandedVariantIds;
-        }
         await this.#validateByVariantIds(variantIds).catch(async () => {
             // TODO: Implement developer-mode logging here. [NL]
             console.warn('Validation failed because of these validation messages still begin present: ', this.validationContext.messages.getMessages());
@@ -865,9 +848,11 @@ export class UmbContentDetailWorkspaceContextBase extends UmbEntityDetailWorkspa
         this.readOnlyGuard.clearRules();
         this.propertyViewGuard.clearRules();
         this.propertyWriteGuard.clearRules();
+        this.nameWriteGuard.clearRules();
         // default:
         this.propertyViewGuard.fallbackToPermitted();
         this.propertyWriteGuard.fallbackToPermitted();
+        this.nameWriteGuard.fallbackToPermitted();
     }
     destroy() {
         this.structure.destroy();