@umbraco-cms/backoffice 17.4.0-rc → 17.4.0-rc2

package/dist-cms/packages/content/content/global-components/content-workspace-property.element.js

@@ -29,7 +29,7 @@ let UmbContentWorkspacePropertyElement = class UmbContentWorkspacePropertyElemen
         });
         // The Content Workspace Context is used to retrieve the property type we like to observe.
         // This gives us the configuration from the property type as part of the data type.
-        this.consumeContext(UMB_CONTENT_WORKSPACE_CONTEXT, async (workspaceContext) => {
+        this.consumeContext(UMB_CONTENT_WORKSPACE_CONTEXT, (workspaceContext) => {
             this._workspaceContext = workspaceContext;
             this.#observePropertyType();
         });

package/dist-cms/packages/core/components/body-layout/body-layout.element.js

@@ -68,7 +68,9 @@ let UmbBodyLayoutElement = class UmbBodyLayoutElement extends LitElement {
             this._navigationSlotHasChildren
             ? ''
             : 'none'}">
-				${this.headline ? html `<h3 id="headline" title=${this.headline}>${this.headline}</h3>` : nothing}
+				${this.headline
+            ? html `<h3 id="headline" title=${this.headline} data-mark="layout-headline">${this.headline}</h3>`
+            : nothing}
 
 				<slot
 					id="header-slot"

package/dist-cms/packages/core/extension-registry/conditions/condition-base.controller.js

@@ -8,7 +8,7 @@ export class UmbConditionBase extends UmbControllerBase {
         if (value === this.#permitted)
             return;
         this.#permitted = value;
-        this.#onChange(value);
+        this.#onChange?.(value);
     }
     #onChange;
     constructor(host, args) {
@@ -17,8 +17,9 @@ export class UmbConditionBase extends UmbControllerBase {
         this.#onChange = args.onChange;
     }
     destroy() {
+        // Clear `#onChange` before `super.destroy()`. [NL]
+        this.#onChange = undefined;
         super.destroy();
         this.config = undefined;
-        this.#onChange = undefined;
     }
 }

package/dist-cms/packages/core/extension-registry/conditions/delay.condition.js

@@ -3,9 +3,13 @@ export class UmbDelayCondition extends UmbConditionBase {
     #timer;
     constructor(host, args) {
         super(host, args);
+        const offset = parseInt(this.config.offset);
+        if (isNaN(offset) || offset <= 0) {
+            throw new Error(`Offset must be a positive number (offset: ${this.config.offset})`);
+        }
         this.#timer = setTimeout(() => {
             this.permitted = true;
-        }, parseInt(this.config.offset));
+        }, offset);
     }
     destroy() {
         clearTimeout(this.#timer);

package/dist-cms/packages/core/extension-registry/conditions/switch.condition.d.ts

@@ -4,8 +4,6 @@ import type { ManifestCondition, UmbConditionConfigBase, UmbConditionControllerA
 export declare class UmbSwitchCondition extends UmbConditionBase<SwitchConditionConfig> implements UmbExtensionCondition {
     #private;
     constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<SwitchConditionConfig>);
-    startApprove(): void;
-    startDisapprove(): void;
     destroy(): void;
 }
 export declare const manifest: ManifestCondition;

package/dist-cms/packages/core/extension-registry/conditions/switch.condition.js

@@ -1,23 +1,29 @@
 import { UmbConditionBase } from './condition-base.controller.js';
 export class UmbSwitchCondition extends UmbConditionBase {
     #timer;
+    #frequency;
     constructor(host, args) {
         super(host, args);
-        this.startApprove();
+        const frequency = parseInt(this.config.frequency);
+        if (isNaN(frequency) || frequency <= 0) {
+            throw new Error(`Frequency must be a positive number (frequency: ${this.config.frequency})`);
+        }
+        this.#frequency = frequency;
+        this.#startApprove();
     }
-    startApprove() {
+    #startApprove() {
         clearTimeout(this.#timer);
         this.#timer = setTimeout(() => {
             this.permitted = true;
-            this.startDisapprove();
-        }, parseInt(this.config.frequency));
+            this.#startDisapprove();
+        }, this.#frequency);
     }
-    startDisapprove() {
+    #startDisapprove() {
         clearTimeout(this.#timer);
         this.#timer = setTimeout(() => {
             this.permitted = false;
-            this.startApprove();
-        }, parseInt(this.config.frequency));
+            this.#startApprove();
+        }, this.#frequency);
     }
     destroy() {
         clearTimeout(this.#timer);

package/dist-cms/packages/core/property/property-guard-manager/property-guard.manager.d.ts

@@ -1,4 +1,4 @@
-import type { Observable } from '../../../../libs/observable-api/index.js';
+import { type Observable } from '../../../../libs/observable-api/index.js';
 import type { UmbReferenceByUnique } from '../../models/index.js';
 import { UmbGuardManagerBase, type UmbGuardRule } from '../../utils/index.js';
 export interface UmbPropertyGuardRule extends UmbGuardRule {

package/dist-cms/packages/core/property/property-guard-manager/property-guard.manager.js

@@ -1,3 +1,4 @@
+import { mergeObservables } from '../../../../libs/observable-api/index.js';
 import { UmbGuardManagerBase } from '../../utils/index.js';
 /**
  *
@@ -21,7 +22,9 @@ export class UmbPropertyGuardManager extends UmbGuardManagerBase {
      * @memberof UmbPropertyGuardManager
      */
     isPermittedForProperty(propertyType) {
-        return this._rules.asObservablePart((rules) => this.#resolvePermission(rules, propertyType));
+        return mergeObservables([this.rules, this._fallback], ([states, fallback]) => {
+            return this.#resolvePermission(states, propertyType) ?? fallback;
+        });
     }
     /**
      * Checks if the property is permitted for the given property type
@@ -30,7 +33,7 @@ export class UmbPropertyGuardManager extends UmbGuardManagerBase {
      * @memberof UmbPropertyGuardManager
      */
     getIsPermittedForProperty(propertyType) {
-        return this.#resolvePermission(this.getRules(), propertyType);
+        return this.#resolvePermission(this.getRules(), propertyType) ?? this._getFallback();
     }
     #resolvePermission(rules, propertyType) {
         if (rules.filter((x) => x.permitted === false).some((rule) => findRule(rule, propertyType))) {
@@ -39,6 +42,6 @@ export class UmbPropertyGuardManager extends UmbGuardManagerBase {
         if (rules.filter((x) => x.permitted === true).some((rule) => findRule(rule, propertyType))) {
             return true;
         }
-        return this._fallback;
+        return undefined;
     }
 }

package/dist-cms/packages/core/property/property-guard-manager/variant-property-guard.manager.d.ts

@@ -1,6 +1,6 @@
 import type { UmbPropertyGuardRule } from './property-guard.manager.js';
 import type { UmbVariantId } from '../../variant/index.js';
-import type { Observable } from '../../../../libs/observable-api/index.js';
+import { type Observable } from '../../../../libs/observable-api/index.js';
 import type { UmbReferenceByUnique } from '../../models/index.js';
 import { UmbGuardManagerBase } from '../../utils/index.js';
 export interface UmbVariantPropertyGuardRule extends UmbPropertyGuardRule {

package/dist-cms/packages/core/property/property-guard-manager/variant-property-guard.manager.js

@@ -1,3 +1,4 @@
+import { mergeObservables } from '../../../../libs/observable-api/index.js';
 import { UmbGuardManagerBase } from '../../utils/index.js';
 /**
  *
@@ -28,7 +29,9 @@ export class UmbVariantPropertyGuardManager extends UmbGuardManagerBase {
      * @memberof UmbVariantPropertyGuardManager
      */
     isPermittedForVariantAndProperty(propertyVariantId, propertyType, datasetVariantId) {
-        return this._rules.asObservablePart((rules) => this.#resolvePermission(rules, propertyVariantId, propertyType, datasetVariantId));
+        return mergeObservables([this.rules, this._fallback], ([rules, fallback]) => {
+            return this.#resolvePermission(rules, propertyVariantId, propertyType, datasetVariantId) ?? fallback;
+        });
     }
     /**
      * Checks if the variant and propertyType is permitted.
@@ -39,7 +42,8 @@ export class UmbVariantPropertyGuardManager extends UmbGuardManagerBase {
      * @memberof UmbVariantPropertyGuardManager
      */
     getIsPermittedForVariantAndProperty(propertyVariantId, propertyType, datasetVariantId) {
-        return this.#resolvePermission(this._rules.getValue(), propertyVariantId, propertyType, datasetVariantId);
+        return (this.#resolvePermission(this._rules.getValue(), propertyVariantId, propertyType, datasetVariantId) ??
+            this._getFallback());
     }
     #resolvePermission(rules, propertyVariantId, propertyType, datasetVariantId) {
         if (rules
@@ -52,6 +56,6 @@ export class UmbVariantPropertyGuardManager extends UmbGuardManagerBase {
             .some((rule) => findRule(rule, propertyVariantId, propertyType, datasetVariantId))) {
             return true;
         }
-        return this._fallback;
+        return undefined;
     }
 }

package/dist-cms/packages/core/recycle-bin/conditions/is-trashed/entity-is-trashed.condition.js

@@ -1,12 +1,13 @@
 import { UMB_IS_TRASHED_ENTITY_CONTEXT } from '../../constants.js';
 import { UmbConditionBase } from '../../../extension-registry/index.js';
+const s = Symbol();
 export class UmbEntityIsTrashedCondition extends UmbConditionBase {
     constructor(host, args) {
         super(host, args);
         this.consumeContext(UMB_IS_TRASHED_ENTITY_CONTEXT, (context) => {
             this.observe(context?.isTrashed, (isTrashed) => {
                 this.permitted = isTrashed === true;
-            });
+            }, s);
         });
     }
 }

package/dist-cms/packages/core/repository/data-mapper/mapping/data-mapping-resolver.js

@@ -35,6 +35,7 @@ export class UmbDataSourceDataMappingResolver extends UmbControllerBase {
             return undefined;
         }
         // Pick the manifest with the highest priority
+        // TODO: We can remove this sorting, it is implemented in the extension registry.
         // TODO: This should have been handled in the extension registry, but until then we do it here: [NL]
         return supportedManifests.sort((a, b) => (b.weight || 0) - (a.weight || 0))[0];
     }

package/dist-cms/packages/core/utils/guard-manager/guard.manager.base.d.ts

@@ -11,17 +11,19 @@ export interface UmbGuardRule extends UmbGuardIncomingRuleBase {
     permitted: boolean;
 }
 export declare abstract class UmbGuardManagerBase<RuleType extends UmbGuardRule = UmbGuardRule, IncomingRuleType extends UmbGuardIncomingRuleBase = UmbPartialSome<RuleType, 'unique' | 'permitted'>> extends UmbControllerBase {
+    #private;
     protected readonly _rules: UmbArrayState<RuleType, unknown>;
     readonly rules: import("rxjs").Observable<RuleType[]>;
     readonly hasRules: import("rxjs").Observable<boolean>;
-    protected _fallback: boolean;
+    protected _fallback: import("rxjs").Observable<boolean>;
+    protected _getFallback(): boolean;
     fallbackToNotPermitted(): void;
     fallbackToPermitted(): void;
     /**
      * Add a new rule
      * @param {RuleType} rule
      */
-    addRule(rule: IncomingRuleType): string | symbol | undefined;
+    addRule(rule: IncomingRuleType): RuleType['unique'];
     /**
      * Add multiple rules
      * @param {RuleType[]} rules

package/dist-cms/packages/core/utils/guard-manager/guard.manager.base.js

@@ -1,5 +1,5 @@
 import { UmbControllerBase } from '../../../../libs/class-api/index.js';
-import { UmbArrayState } from '../../../../libs/observable-api/index.js';
+import { UmbArrayState, UmbBooleanState } from '../../../../libs/observable-api/index.js';
 export class UmbGuardManagerBase extends UmbControllerBase {
     constructor() {
         super(...arguments);
@@ -7,13 +7,18 @@ export class UmbGuardManagerBase extends UmbControllerBase {
         this._rules = new UmbArrayState([], (x) => x.unique);
         this.rules = this._rules.asObservable();
         this.hasRules = this._rules.asObservablePart((x) => x.length > 0);
-        this._fallback = false;
+        this.#fallback = new UmbBooleanState(false);
+        this._fallback = this.#fallback.asObservable();
+    }
+    #fallback;
+    _getFallback() {
+        return this.#fallback.getValue();
     }
     fallbackToNotPermitted() {
-        this._fallback = false;
+        this.#fallback.setValue(false);
     }
     fallbackToPermitted() {
-        this._fallback = true;
+        this.#fallback.setValue(true);
     }
     /**
      * Add a new rule
@@ -26,7 +31,7 @@ export class UmbGuardManagerBase extends UmbControllerBase {
             newRule.permitted = true;
         }
         this._rules.appendOne(newRule);
-        return rule.unique;
+        return newRule.unique;
     }
     /**
      * Add multiple rules

package/dist-cms/packages/core/utils/guard-manager/readonly-guard.manager.js

@@ -1,14 +1,18 @@
+import { mergeObservables } from '../../../../libs/observable-api/index.js';
 import { UmbGuardManagerBase } from './guard.manager.base.js';
 // TODO: Check the need for this one.
 export class UmbReadOnlyGuardManager extends UmbGuardManagerBase {
     constructor() {
         super(...arguments);
-        this.permitted = this._rules.asObservablePart((rules) => {
-            return this.#resolvePermission(rules);
-        });
+        this.permitted = mergeObservables([
+            this._rules.asObservablePart((rules) => {
+                return this.#resolvePermission(rules);
+            }),
+            this._fallback,
+        ], ([permitted, fallback]) => permitted ?? fallback);
     }
     getPermitted() {
-        return this.#resolvePermission(this.getRules());
+        return this.#resolvePermission(this.getRules()) ?? this._getFallback();
     }
     #resolvePermission(rules) {
         if (rules.filter((x) => x.permitted === false).length > 0) {
@@ -17,6 +21,6 @@ export class UmbReadOnlyGuardManager extends UmbGuardManagerBase {
         if (rules.filter((x) => x.permitted === true).length > 0) {
             return true;
         }
-        return this._fallback;
+        return undefined;
     }
 }

package/dist-cms/packages/core/utils/guard-manager/readonly-variant-guard.manager.d.ts

@@ -22,10 +22,20 @@ export declare class UmbReadOnlyVariantGuardManager extends UmbReadOnlyGuardMana
     isPermittedForVariant(variantId: UmbVariantId): Observable<boolean>;
     /**
      * @param {Observable<UmbVariantId | undefined>} variantId
-     * @returns {Observable<boolean>} - Observable that emits true if the variantId is permitted to read, false otherwise
+     * @returns {Observable<boolean | undefined>} - Observable that emits true if the variantId is permitted to read, false otherwise
+     * @memberof UmbReadOnlyVariantGuardManager
+     */
+    isPermittedForObservableVariant(variantId: Observable<UmbVariantId | undefined>): Observable<boolean | undefined>;
+    /**
+     * Observe the permission for multiple given variantIds
+     * @param {Observable<UmbVariantId[]>} variantIds - Observable emitting the variantIds to evaluate
+     * @returns {Observable<{ variantId: UmbVariantId; permitted: boolean }[]>} - Observable that emits an array of objects with a permitted boolean and the variantId
      * @memberof UmbReadOnlyVariantGuardManager
      */
-    isPermittedForObservableVariant(variantId: Observable<UmbVariantId | undefined>): Observable<boolean>;
+    isPermittedForObservableVariants(variantIds: Observable<UmbVariantId[]>): Observable<{
+        variantId: UmbVariantId;
+        permitted: boolean;
+    }[]>;
     /**
      * Check if the given variantId is permitted to read
      * @param {UmbVariantId} variantId

package/dist-cms/packages/core/utils/guard-manager/readonly-variant-guard.manager.js

@@ -8,7 +8,6 @@ import { mergeObservables } from '../../../../libs/observable-api/index.js';
 function findRule(rule, variantId) {
     return rule.variantId?.compare(variantId) || rule.variantId === undefined;
 }
-// TODO: Check the need for this one.
 /**
  * Read only guard manager for variant rules.
  * @export
@@ -23,22 +22,38 @@ export class UmbReadOnlyVariantGuardManager extends UmbReadOnlyGuardManager {
      * @memberof UmbReadOnlyVariantGuardManager
      */
     isPermittedForVariant(variantId) {
-        return this._rules.asObservablePart((states) => {
-            return this.#resolvePermission(states, variantId);
-        });
+        return mergeObservables([
+            this._rules.asObservablePart((rules) => {
+                return this.#resolvePermission(rules, variantId);
+            }),
+            this._fallback,
+        ], ([permitted, fallback]) => permitted ?? fallback);
     }
     /**
      * @param {Observable<UmbVariantId | undefined>} variantId
-     * @returns {Observable<boolean>} - Observable that emits true if the variantId is permitted to read, false otherwise
+     * @returns {Observable<boolean | undefined>} - Observable that emits true if the variantId is permitted to read, false otherwise
      * @memberof UmbReadOnlyVariantGuardManager
      */
     isPermittedForObservableVariant(variantId) {
-        return mergeObservables([this.rules, variantId], ([states, variantId]) => {
+        return mergeObservables([this.rules, variantId, this._fallback], ([rules, variantId, fallback]) => {
             if (!variantId) {
-                // Or should we know about the fallback state here? [NL]
-                return false;
+                return undefined;
+            }
+            return this.#resolvePermission(rules, variantId) ?? fallback;
+        });
+    }
+    /**
+     * Observe the permission for multiple given variantIds
+     * @param {Observable<UmbVariantId[]>} variantIds - Observable emitting the variantIds to evaluate
+     * @returns {Observable<{ variantId: UmbVariantId; permitted: boolean }[]>} - Observable that emits an array of objects with a permitted boolean and the variantId
+     * @memberof UmbReadOnlyVariantGuardManager
+     */
+    isPermittedForObservableVariants(variantIds) {
+        return mergeObservables([this.rules, variantIds, this._fallback], ([rules, variantIds, fallback]) => {
+            if (!variantIds || variantIds.length === 0) {
+                return [];
             }
-            return this.#resolvePermission(states, variantId);
+            return variantIds.map((id) => ({ variantId: id, permitted: this.#resolvePermission(rules, id) ?? fallback }));
         });
     }
     /**
@@ -48,7 +63,7 @@ export class UmbReadOnlyVariantGuardManager extends UmbReadOnlyGuardManager {
      * @memberof UmbReadOnlyVariantGuardManager
      */
     getIsPermittedForVariant(variantId) {
-        return this.#resolvePermission(this.getRules(), variantId);
+        return this.#resolvePermission(this.getRules(), variantId) ?? this._getFallback();
     }
     #resolvePermission(rules, variantId) {
         if (rules.filter((x) => x.permitted === false).some((rule) => findRule(rule, variantId))) {
@@ -57,6 +72,6 @@ export class UmbReadOnlyVariantGuardManager extends UmbReadOnlyGuardManager {
         if (rules.filter((x) => x.permitted === true).some((rule) => findRule(rule, variantId))) {
             return true;
         }
-        return this._fallback;
+        return undefined;
     }
 }

package/dist-cms/packages/core/variant/variant-id.class.d.ts

@@ -5,6 +5,10 @@ export declare const UMB_INVARIANT_CULTURE = "invariant";
  * The identifier is not specific for ContentType Variants, but is used for many type of identification of a culture and a segment. One case is any property of a ContentType can be resolved into a VariantId depending on their structural settings such as Vary by Culture and Vary by Segmentation.
  */
 export declare class UmbVariantId {
+    /**
+     * A frozen instance of the UmbVariantId class representing the invariant variant, meaning it has no culture and no segment.
+     */
+    static readonly INVARIANT: Readonly<UmbVariantId>;
     static Create(variantData: UmbObjectWithVariantProperties): UmbVariantId;
     static CreateFromPartial(variantData: Partial<UmbObjectWithVariantProperties>): UmbVariantId;
     static CreateInvariant(): UmbVariantId;

package/dist-cms/packages/core/variant/variant-id.class.js

@@ -4,6 +4,10 @@ export const UMB_INVARIANT_CULTURE = 'invariant';
  * The identifier is not specific for ContentType Variants, but is used for many type of identification of a culture and a segment. One case is any property of a ContentType can be resolved into a VariantId depending on their structural settings such as Vary by Culture and Vary by Segmentation.
  */
 export class UmbVariantId {
+    /**
+     * A frozen instance of the UmbVariantId class representing the invariant variant, meaning it has no culture and no segment.
+     */
+    static { this.INVARIANT = Object.freeze(new UmbVariantId(null, null)); }
     static Create(variantData) {
         return Object.freeze(new UmbVariantId(variantData.culture, variantData.segment));
     }
@@ -11,7 +15,7 @@ export class UmbVariantId {
         return Object.freeze(new UmbVariantId(variantData.culture, variantData.segment));
     }
     static CreateInvariant() {
-        return Object.freeze(new UmbVariantId(null, null));
+        return UmbVariantId.INVARIANT;
     }
     static FromString(str) {
         const firstUnderscoreIndex = str.indexOf('_');

package/dist-cms/packages/core/workspace/components/workspace-action/common/submit/submit.action.d.ts

@@ -5,9 +5,9 @@ import type { UmbSubmitWorkspaceActionArgs } from './types.js';
 import type { UmbControllerHost } from '../../../../../../../libs/controller-api/index.js';
 export declare class UmbSubmitWorkspaceAction<ArgsMetaType extends MetaWorkspaceAction = MetaWorkspaceAction, WorkspaceContextType extends UmbSubmittableWorkspaceContext = UmbSubmittableWorkspaceContext> extends UmbWorkspaceActionBase<ArgsMetaType> {
     #private;
-    protected _retrieveWorkspaceContext: Promise<unknown>;
+    protected _retrieveWorkspaceContext?: Promise<unknown>;
     protected _workspaceContext?: WorkspaceContextType;
     constructor(host: UmbControllerHost, args: UmbSubmitWorkspaceActionArgs<ArgsMetaType>);
     protected _gotWorkspaceContext(): void;
-    execute(): Promise<void>;
+    execute(): Promise<void | undefined>;
 }

package/dist-cms/packages/core/workspace/components/workspace-action/common/submit/submit.action.js

@@ -8,10 +8,16 @@ export class UmbSubmitWorkspaceAction extends UmbWorkspaceActionBase {
             this._workspaceContext = context;
             this.#observeUnique();
             this._gotWorkspaceContext();
-        }).asPromise();
+        })
+            .asPromise()
+            .catch(() => {
+            return undefined;
+        });
     }
     #observeUnique() {
         this.observe(this._workspaceContext?.unique, (unique) => {
+            if (!this._workspaceContext)
+                return;
             // We can't save if we don't have a unique
             if (unique === undefined) {
                 this.disable();
@@ -27,6 +33,6 @@ export class UmbSubmitWorkspaceAction extends UmbWorkspaceActionBase {
     }
     async execute() {
         await this._retrieveWorkspaceContext;
-        return await this._workspaceContext.requestSubmit();
+        return await this._workspaceContext?.requestSubmit();
     }
 }

package/dist-cms/packages/core/workspace/components/workspace-split-view/workspace-split-view-variant-selector.element.js

@@ -13,7 +13,7 @@ import { UmbDataPathVariantQuery, umbBindToValidation } from '../../../validatio
 import { UMB_PROPERTY_DATASET_CONTEXT, isNameablePropertyDatasetContext } from '../../../property/index.js';
 import { UUIInputEvent } from '../../../../../external/uui/index.js';
 import { UMB_HINT_CONTEXT } from '../../../hint/index.js';
-import { observeMultiple } from '../../../../../libs/observable-api/index.js';
+import { createObservablePart, observeMultiple } from '../../../../../libs/observable-api/index.js';
 let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVariantSelectorElement extends UmbLitElement {
     #splitViewContext;
     #datasetContext;
@@ -46,8 +46,8 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
             const workspaceContext = this.#splitViewContext?.getWorkspaceContext();
             this.#observeVariants(workspaceContext);
             this.#observeActiveVariants(workspaceContext);
+            this.#observeReadOnlyCultures(workspaceContext);
             this.#observeCurrentVariant();
-            this.#observeReadOnlyGuardRules(workspaceContext);
             this.observe(workspaceContext?.variesBySegment, (value) => (this._variesBySegment = value ?? false), 'umbObserveVariesBySegment');
             this.observe(workspaceContext?.variesByCulture, (value) => (this._variesByCulture = value ?? false), 'umbObserveVariesByCulture');
         });
@@ -79,7 +79,6 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
         this.observe(workspaceContext?.variantOptions, (variantOptions) => {
             this._variantOptions = (variantOptions ?? []).sort(this._variantSorter);
             this._cultureVariantOptions = this._variantOptions.filter((variant) => variant.segment === null);
-            this.#setReadOnlyCultures(workspaceContext);
         }, '_observeVariantOptions');
         if (workspaceContext) {
             this.observe(observeMultiple([
@@ -122,9 +121,6 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
             this._activeVariant = option;
         }, 'umbObserveActiveVariant');
     }
-    #observeReadOnlyGuardRules(workspaceContext) {
-        this.observe(workspaceContext?.readOnlyGuard.rules, () => this.#setReadOnlyCultures(workspaceContext), 'umbObserveReadOnlyGuardRules');
-    }
     #handleInput(event) {
         if (event instanceof UUIInputEvent) {
             const target = event.composedPath()[0];
@@ -158,14 +154,15 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
         }
         return this._variantOptions.length > 1;
     }
-    #setReadOnlyCultures(workspaceContext) {
+    #observeReadOnlyCultures(workspaceContext) {
         if (workspaceContext) {
-            this._readOnlyCultures = this._variantOptions
-                .filter((variant) => workspaceContext.readOnlyGuard.getIsPermittedForVariant(UmbVariantId.Create(variant)))
-                .map((variant) => variant.culture);
+            this.observe(workspaceContext.readOnlyGuard.isPermittedForObservableVariants(createObservablePart(workspaceContext.variantOptions, (options) => options.map((option) => UmbVariantId.Create(option)))), (permitted) => {
+                this._readOnlyCultures = permitted.filter((p) => p.permitted === true).map((p) => p.variantId.culture);
+            }, '_observeReadOnlyCultures');
         }
         else {
             this._readOnlyCultures = [];
+            this.removeUmbControllerByAlias('_observeReadOnlyCultures');
         }
     }
     #onPopoverToggle(event) {

package/dist-cms/packages/core/workspace/namable/name-write-guard.manager.js

@@ -1,7 +1,10 @@
+import { mergeObservables } from '../../../../libs/observable-api/index.js';
 import { UmbGuardManagerBase } from '../../utils/index.js';
 export class UmbNameWriteGuardManager extends UmbGuardManagerBase {
     isPermittedForName() {
-        return this._rules.asObservablePart((rules) => this.#resolvePermission(rules));
+        return mergeObservables([this.rules, this._fallback], ([rules, fallback]) => {
+            return this.#resolvePermission(rules) ?? fallback;
+        });
     }
     #resolvePermission(rules) {
         if (rules.some((rule) => rule.permitted === false)) {
@@ -10,6 +13,6 @@ export class UmbNameWriteGuardManager extends UmbGuardManagerBase {
         if (rules.some((rule) => rule.permitted === true)) {
             return true;
         }
-        return this._fallback;
+        return undefined;
     }
 }

package/dist-cms/packages/core/workspace/workspace.element.d.ts

@@ -1,11 +1,9 @@
-import { type PropertyValueMap } from '../../../external/lit/index.js';
 import { UmbLitElement } from '../lit-element/index.js';
 export declare class UmbWorkspaceElement extends UmbLitElement {
     #private;
     private _component?;
     get entityType(): string | undefined;
     set entityType(value: string);
-    protected firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
     render(): HTMLElement | import("lit-html").TemplateResult<1>;
 }
 export { UmbWorkspaceElement as element };

package/dist-cms/packages/core/workspace/workspace.element.js

@@ -24,14 +24,11 @@ let UmbWorkspaceElement = class UmbWorkspaceElement extends UmbLitElement {
         this.#entityType = value;
         this.#createController(value);
     }
-    firstUpdated(_changedProperties) {
-        super.firstUpdated(_changedProperties);
-        this.setAttribute(UMB_MARK_ATTRIBUTE_NAME, 'workspace');
-    }
     #createController(entityType) {
         if (this.#extensionsController) {
             this.#extensionsController.destroy();
         }
+        this.setAttribute(UMB_MARK_ATTRIBUTE_NAME, 'workspace:' + entityType);
         this.#extensionsController = new UmbExtensionsElementAndApiInitializer(this, umbExtensionsRegistry, 'workspace', apiArgsCreator, (manifest) => manifest.meta.entityType === entityType, (extensionControllers) => {
             this._component = extensionControllers[0]?.component;
             const api = extensionControllers[0]?.api;

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

@@ -1,11 +1,12 @@
 import { UMB_DOCUMENT_TYPE_PROPERTY_TYPE_ENTITY_TYPE } from './entity.js';
+import { UmbDocumentTypePropertyTypeReferenceResponseManagementApiDataMapping } from './document-type-property-type-reference-response.management-api.mapping.js';
 import { UMB_MANAGEMENT_API_DATA_SOURCE_ALIAS } from '../../../core/repository/index.js';
 export const manifests = [
     {
         type: 'dataSourceDataMapping',
         alias: 'Umb.DataSourceDataMapping.ManagementApi.DocumentTypePropertyTypeReferenceResponse',
         name: 'Document Type Property Type Reference Response Management Api Data Mapping',
-        api: () => import('./document-type-property-type-reference-response.management-api.mapping.js'),
+        api: UmbDocumentTypePropertyTypeReferenceResponseManagementApiDataMapping,
         forDataSource: UMB_MANAGEMENT_API_DATA_SOURCE_ALIAS,
         forDataModel: 'DocumentTypePropertyTypeReferenceResponseModel',
     },

package/dist-cms/packages/documents/documents/reference/repository/manifests.js

@@ -1,4 +1,5 @@
 import { UMB_DOCUMENT_REFERENCE_REPOSITORY_ALIAS } from './constants.js';
+import { UmbDocumentReferenceResponseManagementApiDataMapping } from './document-reference-response.management-api.mapping.js';
 import { UMB_MANAGEMENT_API_DATA_SOURCE_ALIAS } from '../../../../core/repository/index.js';
 export const manifests = [
     {
@@ -11,7 +12,7 @@ export const manifests = [
         type: 'dataSourceDataMapping',
         alias: 'Umb.DataSourceDataMapping.ManagementApi.DocumentReferenceResponse',
         name: 'Document Reference Response Management Api Data Mapping',
-        api: () => import('./document-reference-response.management-api.mapping.js'),
+        api: UmbDocumentReferenceResponseManagementApiDataMapping,
         forDataSource: UMB_MANAGEMENT_API_DATA_SOURCE_ALIAS,
         forDataModel: 'DocumentReferenceResponseModel',
     },

package/dist-cms/packages/documents/documents/user-permissions/document-property-value/conditions/document-property-value-user-permission.condition.js

@@ -8,6 +8,8 @@ export class UmbDocumentPropertyValueUserPermissionCondition extends UmbConditio
         super(host, args);
         this.consumeContext(UMB_CURRENT_USER_CONTEXT, (context) => {
             this.observe(context?.currentUser, (currentUser) => {
+                if (!currentUser)
+                    return;
                 this.#documentPropertyValuePermissions =
                     currentUser?.permissions?.filter(isDocumentPropertyValueUserPermission) || [];
                 this.#fallbackPermissions = currentUser?.fallbackPermissions || [];