@umbraco-cms/backoffice 17.2.1 → 17.3.0-rc

package/dist-cms/libs/context-api/consume/context-consumer.js

@@ -7,7 +7,9 @@ import { UmbContextRequestEventImplementation } from './context-request.event.js
  * Alternatively, you can use the `UmbContextConsumerController` to consume a context from a host element. But this does require that you can implement one of the Class Mixins mentioned above.
  */
 export class UmbContextConsumer {
-    #raf;
+    #attached;
+    #requestRaf;
+    #disconnectAC;
     #skipHost;
     #stopAtContextMatch;
     #callback;
@@ -30,6 +32,7 @@ export class UmbContextConsumer {
      * @memberof UmbContextConsumer
      */
     constructor(host, contextIdentifier, callback) {
+        this.#attached = false;
         this.#stopAtContextMatch = true;
         this._onResponse = (instance) => {
             if (this.#instance === instance) {
@@ -52,7 +55,6 @@ export class UmbContextConsumer {
             }
             return false;
         };
-        this.#currentTarget = window;
         this.#onProvide = (event) => {
             // Does seem a bit unnecessary, we could just assume the type via type casting...
             if (!isUmbContextProvideEventType(event))
@@ -66,6 +68,7 @@ export class UmbContextConsumer {
             if (!isUmbContextUnprovidedEventType(event))
                 return;
             if (this.#contextAlias === event.contextAlias && event.instance === this.#instance) {
+                this.#setCurrentScope(window);
                 this.#unprovide();
             }
         };
@@ -107,7 +110,7 @@ export class UmbContextConsumer {
     }
     async setInstance(instance) {
         this.#instance = instance;
-        this.#setCurrentTarget(instance.getHostElement());
+        this.#setCurrentScope(instance.getHostElement());
         await this.#callback?.(instance); // Resolve callback first as it might perform something you like completed before resolving the promise, as the promise might be used to determine when things are ready/initiated [NL]
         this.#resolvePromise();
     }
@@ -166,8 +169,8 @@ export class UmbContextConsumer {
      * @description Request the context from the host element.
      */
     request() {
-        if (this.#raf !== undefined) {
-            cancelAnimationFrame(this.#raf);
+        if (this.#requestRaf !== undefined) {
+            cancelAnimationFrame(this.#requestRaf);
         }
         const hostElement = this._retrieveHost();
         // Add connection check to prevent requesting on disconnected elements
@@ -178,22 +181,41 @@ export class UmbContextConsumer {
         const event = new UmbContextRequestEventImplementation(this.#contextAlias, this.#apiAlias, this._onResponse, this.#stopAtContextMatch);
         (this.#skipHost ? hostElement?.parentNode : hostElement)?.dispatchEvent(event);
         if (this.#promiseResolver && this.#promiseOptions?.preventTimeout !== true) {
-            this.#raf = requestAnimationFrame(() => {
+            this.#requestRaf = requestAnimationFrame(() => {
                 // For unproviding, then setInstance to undefined here. [NL]
                 this.#rejectPromise();
-                this.#raf = undefined;
+                this.#requestRaf = undefined;
             });
         }
     }
     hostConnected() {
-        this.#setupCurrentTarget();
+        this.#attached = true;
+        if (this.#disconnectAC) {
+            this.#disconnectAC.abort();
+            this.#disconnectAC = undefined;
+        }
+        this.#setCurrentScope(window);
         this.request();
     }
     hostDisconnected() {
-        if (this.#raf !== undefined) {
-            cancelAnimationFrame(this.#raf);
-            this.#raf = undefined;
+        if (!this.#attached)
+            return;
+        this.#attached = false;
+        if (this.#requestRaf !== undefined) {
+            cancelAnimationFrame(this.#requestRaf);
+            this.#requestRaf = undefined;
         }
+        this.#disconnectAC?.abort();
+        this.#setCurrentScope(undefined);
+        const abortController = (this.#disconnectAC = new AbortController());
+        queueMicrotask(() => {
+            if (!abortController.signal.aborted) {
+                this.#handleDisconnect();
+            }
+        });
+    }
+    #handleDisconnect() {
+        this.#disconnectAC = undefined;
         this.#unprovide();
         if (this.#promiseRejecter) {
             const hostElement = this._retrieveHost();
@@ -203,24 +225,24 @@ export class UmbContextConsumer {
         this.#promiseOptions = undefined;
         this.#promiseResolver = undefined;
         this.#promiseRejecter = undefined;
-        this.#dismentalCurrentTarget();
-        this.#currentTarget = window;
-    }
-    #currentTarget;
-    #setCurrentTarget(target) {
-        this.#dismentalCurrentTarget();
-        this.#currentTarget = target ?? window;
-        this.#setupCurrentTarget();
     }
-    #setupCurrentTarget() {
-        this.#currentTarget.addEventListener(UMB_CONTEXT_PROVIDE_EVENT_TYPE, this.#onProvide);
-        // TODO: consider not listening if it does not have a Context....
-        this.#currentTarget.addEventListener(UMB_CONTEXT_UNPROVIDED_EVENT_TYPE, this.#onUnprovided);
+    // The current scope of which is being listened to for context providing/unproviding, this is usually the host element or the provided context's host element. [NL]
+    #currentScope;
+    #setCurrentScope(scope) {
+        if (this.#currentScope !== scope) {
+            this.#dismantleCurrentScope();
+            this.#currentScope = scope;
+            // Setup the scope event listening:
+            this.#currentScope?.addEventListener(UMB_CONTEXT_PROVIDE_EVENT_TYPE, this.#onProvide);
+            // TODO: consider not listening if it does not have a Context....
+            this.#currentScope?.addEventListener(UMB_CONTEXT_UNPROVIDED_EVENT_TYPE, this.#onUnprovided);
+        }
     }
-    #dismentalCurrentTarget() {
-        if (this.#currentTarget) {
-            this.#currentTarget.removeEventListener(UMB_CONTEXT_PROVIDE_EVENT_TYPE, this.#onProvide);
-            this.#currentTarget.removeEventListener(UMB_CONTEXT_UNPROVIDED_EVENT_TYPE, this.#onUnprovided);
+    // dismantle the current scope event listening:
+    #dismantleCurrentScope() {
+        if (this.#currentScope) {
+            this.#currentScope.removeEventListener(UMB_CONTEXT_PROVIDE_EVENT_TYPE, this.#onProvide);
+            this.#currentScope.removeEventListener(UMB_CONTEXT_UNPROVIDED_EVENT_TYPE, this.#onUnprovided);
         }
     }
     #onProvide;
@@ -232,13 +254,17 @@ export class UmbContextConsumer {
         }
     }
     destroy() {
-        this.hostDisconnected();
+        if (this.#requestRaf !== undefined) {
+            cancelAnimationFrame(this.#requestRaf);
+        }
+        this.#disconnectAC?.abort();
+        this.#disconnectAC = undefined;
+        this.#dismantleCurrentScope();
+        this.#handleDisconnect();
+        this.#currentScope = undefined;
         this._retrieveHost = undefined;
+        this.#attached = false;
         this.#callback = undefined;
-        this.#promise = undefined;
-        this.#promiseOptions = undefined;
-        this.#promiseResolver = undefined;
-        this.#promiseRejecter = undefined;
         this.#instance = undefined;
         this.#discriminator = undefined;
     }

package/dist-cms/packages/block/block/conditions/block-workspace-is-readonly.condition.d.ts

@@ -0,0 +1,8 @@
+import type { BlockWorkspaceIsReadOnlyConditionConfig } from './types.js';
+import { UmbConditionBase } from '../../../core/extension-registry/index.js';
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from '../../../../libs/extension-api/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export declare class UmbBlockWorkspaceIsReadOnlyCondition extends UmbConditionBase<BlockWorkspaceIsReadOnlyConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<BlockWorkspaceIsReadOnlyConditionConfig>);
+}
+export default UmbBlockWorkspaceIsReadOnlyCondition;

package/dist-cms/packages/block/block/conditions/block-workspace-is-readonly.condition.js

@@ -0,0 +1,15 @@
+import { UMB_BLOCK_WORKSPACE_CONTEXT } from '../index.js';
+import { UmbConditionBase } from '../../../core/extension-registry/index.js';
+export class UmbBlockWorkspaceIsReadOnlyCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_BLOCK_WORKSPACE_CONTEXT, (context) => {
+            this.observe(context?.readOnlyGuard.permitted, (isReadOnly) => {
+                if (isReadOnly !== undefined) {
+                    this.permitted = isReadOnly === (this.config.match !== undefined ? this.config.match : true);
+                }
+            }, 'observeIsReadOnly');
+        });
+    }
+}
+export default UmbBlockWorkspaceIsReadOnlyCondition;

package/dist-cms/packages/block/block/conditions/manifests.js

@@ -1,6 +1,7 @@
 import UmbBlockEntryShowContentEditCondition from './block-entry-show-content-edit.condition.js';
 import UmbBlockWorkspaceHasSettingsCondition from './block-workspace-has-settings.condition.js';
 import UmbBlockEntryIsExposedCondition from './block-workspace-is-exposed.condition.js';
+import UmbBlockWorkspaceIsReadOnlyCondition from './block-workspace-is-readonly.condition.js';
 export const manifests = [
     {
         type: 'condition',
@@ -20,4 +21,10 @@ export const manifests = [
         alias: 'Umb.Condition.BlockWorkspaceIsExposed',
         api: UmbBlockEntryIsExposedCondition,
     },
+    {
+        type: 'condition',
+        name: 'Block Workspace Is ReadOnly Condition',
+        alias: 'Umb.Condition.BlockWorkspaceIsReadOnly',
+        api: UmbBlockWorkspaceIsReadOnlyCondition,
+    },
 ];

package/dist-cms/packages/block/block/conditions/types.d.ts

@@ -4,8 +4,11 @@ export type BlockEntryShowContentEditConditionConfig = UmbConditionConfigBase<'U
 export interface BlockEntryIsExposedConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockWorkspaceIsExposed'> {
     match?: boolean;
 }
+export interface BlockWorkspaceIsReadOnlyConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockWorkspaceIsReadOnly'> {
+    match?: boolean;
+}
 declare global {
     interface UmbExtensionConditionConfigMap {
-        umbBlock: BlockEntryShowContentEditConditionConfig | BlockWorkspaceHasSettingsConditionConfig | BlockEntryIsExposedConditionConfig;
+        umbBlock: BlockEntryShowContentEditConditionConfig | BlockWorkspaceHasSettingsConditionConfig | BlockEntryIsExposedConditionConfig | BlockWorkspaceIsReadOnlyConditionConfig;
     }
 }

package/dist-cms/packages/block/block/context/block-manager.context.d.ts

@@ -129,5 +129,6 @@ export declare abstract class UmbBlockManagerContext<BlockType extends UmbBlockT
     }>;
     abstract insert(layoutEntry: BlockLayoutType, content: UmbBlockDataModel, settings: UmbBlockDataModel | undefined, originData: BlockOriginDataType): boolean;
     protected insertBlockData(layoutEntry: BlockLayoutType, content: UmbBlockDataModel, settings: UmbBlockDataModel | undefined, _originData: BlockOriginDataType): void;
+    protected notifyBlockInserted(layoutEntry: BlockLayoutType, originData: BlockOriginDataType): Promise<void>;
     protected removeBlockKey(contentKey: string): void;
 }

package/dist-cms/packages/block/block/context/block-manager.context.js

@@ -1,3 +1,4 @@
+import { UmbBlockInsertedEvent } from '../events/block-inserted.event.js';
 import { UMB_BLOCK_MANAGER_CONTEXT } from './block-manager.context-token.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbArrayState, UmbBooleanState, UmbClassState, UmbStringState, mergeObservables, } from '../../../../libs/observable-api/index.js';
@@ -131,22 +132,63 @@ export class UmbBlockManagerContext extends UmbContextBase {
         this.#exposes = new UmbArrayState([], (x) => x.contentKey + '_' + x.culture + '_' + x.segment);
         this.exposes = this.#exposes.asObservable();
         this.observe(this.blockTypes, (blockTypes) => {
-            blockTypes.forEach((x) => {
-                this.#ensureContentType(x.contentElementTypeKey);
-                if (x.settingsElementTypeKey) {
-                    this.#ensureContentType(x.settingsElementTypeKey);
-                }
-            });
+            this.#ensureContentTypes(blockTypes);
         }, null);
     }
-    async #ensureContentType(unique) {
-        if (this.#structures.find((x) => x.getOwnerContentTypeUnique() === unique))
+    #ensureContentTypes(blockTypes) {
+        // Collect all unique content type keys
+        const allUniques = new Set();
+        blockTypes.forEach((x) => {
+            allUniques.add(x.contentElementTypeKey);
+            if (x.settingsElementTypeKey) {
+                allUniques.add(x.settingsElementTypeKey);
+            }
+        });
+        // Filter out already loaded types
+        const uniquesToFetch = [...allUniques].filter((unique) => !this.#structures.find((x) => x.getOwnerContentTypeUnique() === unique));
+        if (uniquesToFetch.length === 0)
             return;
-        // Lets try to go with the UmbContentTypeModel, to make this as compatible with other ContentTypes as possible, but maybe if off with this as Blocks are always based on ElementTypes.. [NL]
-        const structure = new UmbContentTypeStructureManager(this, this.#contentTypeRepository);
-        const initialRequest = structure.loadType(unique);
-        this.#contentTypeRequests.push(initialRequest);
-        this.#structures.push(structure);
+        // IMPORTANT: Create and register all structure managers SYNCHRONOUSLY first
+        // This ensures getStructure() can find them immediately, before any async operations
+        const structuresToInit = [];
+        for (const unique of uniquesToFetch) {
+            const structure = new UmbContentTypeStructureManager(this, this.#contentTypeRepository);
+            // Set the unique synchronously so getStructure() can find it immediately
+            structure.setOwnerContentTypeUnique(unique);
+            this.#structures.push(structure);
+            structuresToInit.push({ structure, unique });
+        }
+        // Now perform async initialization — push the promise synchronously so
+        // contentTypesLoaded (Promise.all(#contentTypeRequests)) properly waits.
+        this.#contentTypeRequests.push(this.#initializeStructures(structuresToInit));
+    }
+    async #initializeStructures(structuresToInit) {
+        const uniques = structuresToInit.map((x) => x.unique);
+        // Bulk fetch all content types if supported
+        const contentTypesMap = new Map();
+        if (this.#contentTypeRepository.requestByUniques) {
+            const { error, data } = await this.#contentTypeRepository.requestByUniques(uniques);
+            if (error || !data) {
+                throw error?.message ?? 'Repository could not request Content Types by Uniques.';
+            }
+            if (data) {
+                data.forEach((item) => contentTypesMap.set(item.unique, item));
+            }
+        }
+        // Initialize each structure with pre-fetched data or fall back to individual loading
+        const initPromises = [];
+        for (const { structure, unique } of structuresToInit) {
+            const contentType = contentTypesMap.get(unique);
+            if (contentType) {
+                // Use pre-fetched data directly via setType to avoid re-fetching
+                initPromises.push(structure.setType(contentType));
+            }
+            else {
+                // Fallback to individual load if not in bulk response
+                initPromises.push(structure.loadType(unique));
+            }
+        }
+        await Promise.all(initPromises);
     }
     getStructure(unique) {
         return this.#structures.find((x) => x.getOwnerContentTypeUnique() === unique);
@@ -400,6 +442,14 @@ export class UmbBlockManagerContext extends UmbContextBase {
         // Expose inserted block:
         this.#setInitialBlockExpose(content);
     }
+    async notifyBlockInserted(layoutEntry, originData) {
+        // Await one rendering frame, to make sure new Block has been rendered at the time of the Event firing. [NL]
+        await new Promise((resolve) => requestAnimationFrame(() => resolve(true)));
+        this.dispatchEvent(new UmbBlockInsertedEvent({
+            originData,
+            layout: layoutEntry,
+        }));
+    }
     async #setInitialBlockExpose(content) {
         await this.contentTypesLoaded;
         const contentStructure = this.getStructure(content.contentTypeKey);

package/dist-cms/packages/block/block/events/block-inserted.event.d.ts

@@ -0,0 +1,14 @@
+import type { UmbBlockLayoutBaseModel } from '../types.js';
+export interface UmbBlockInsertedEventDetail<TLayoutModel extends UmbBlockLayoutBaseModel = UmbBlockLayoutBaseModel, TOriginData = unknown> {
+    originData: TOriginData;
+    layout: TLayoutModel;
+}
+export declare class UmbBlockInsertedEvent<TLayoutModel extends UmbBlockLayoutBaseModel = UmbBlockLayoutBaseModel, TOriginData = unknown> extends CustomEvent<UmbBlockInsertedEventDetail<TLayoutModel, TOriginData>> {
+    static readonly TYPE = "umb-internal:blockInserted";
+    constructor(detail: UmbBlockInsertedEventDetail<TLayoutModel, TOriginData>);
+}
+declare global {
+    interface GlobalEventHandlersEventMap {
+        [UmbBlockInsertedEvent.TYPE]: UmbBlockInsertedEvent;
+    }
+}

package/dist-cms/packages/block/block/events/block-inserted.event.js

@@ -0,0 +1,6 @@
+export class UmbBlockInsertedEvent extends CustomEvent {
+    static { this.TYPE = 'umb-internal:blockInserted'; }
+    constructor(detail) {
+        super(UmbBlockInsertedEvent.TYPE, { detail, bubbles: false, composed: false, cancelable: false });
+    }
+}

package/dist-cms/packages/block/block/events/index.d.ts

@@ -0,0 +1 @@
+export * from './block-inserted.event.js';

package/dist-cms/packages/block/block/events/index.js

@@ -0,0 +1 @@
+export * from './block-inserted.event.js';

package/dist-cms/packages/block/block/index.d.ts

@@ -1,6 +1,7 @@
 export * from './clipboard/index.js';
 export * from './components/index.js';
 export * from './context/index.js';
+export * from './events/index.js';
 export * from './modals/index.js';
 export * from './property-value-cloner/index.js';
 export * from './property-value-resolver/index.js';

package/dist-cms/packages/block/block/index.js

@@ -1,6 +1,7 @@
 export * from './clipboard/index.js';
 export * from './components/index.js';
 export * from './context/index.js';
+export * from './events/index.js';
 export * from './modals/index.js';
 export * from './property-value-cloner/index.js';
 export * from './property-value-resolver/index.js';

package/dist-cms/packages/block/block/workspace/block-element-manager.d.ts

@@ -11,7 +11,7 @@ import { UmbValidationController } from '../../../core/validation/index.js';
 import { type UmbElementPropertyDataOwner } from '../../../content/content/index.js';
 import { UmbReadOnlyVariantGuardManager } from '../../../core/utils/index.js';
 import { UmbVariantPropertyGuardManager } from '../../../core/property/index.js';
-import { UmbHintContext, type UmbVariantHint } from '../../../core/hint/index.js';
+import { UmbViewContext } from '../../../core/view/index.js';
 export declare class UmbBlockElementManager<LayoutDataType extends UmbBlockLayoutBaseModel = UmbBlockLayoutBaseModel> extends UmbControllerBase implements UmbElementPropertyDataOwner<UmbBlockDataModel, UmbContentTypeModel> {
     #private;
     readonly data: Observable<UmbBlockDataModel | undefined>;
@@ -27,7 +27,7 @@ export declare class UmbBlockElementManager<LayoutDataType extends UmbBlockLayou
     readonly propertyViewGuard: UmbVariantPropertyGuardManager;
     readonly propertyWriteGuard: UmbVariantPropertyGuardManager;
     readonly validation: UmbValidationController;
-    readonly hints: UmbHintContext<UmbVariantHint, import("../../../core/utils/index.js").UmbPartialSome<UmbVariantHint, "weight" | "path" | "unique">>;
+    readonly view: UmbViewContext;
     constructor(host: UmbBlockWorkspaceContext<LayoutDataType>, dataPathPropertyName: string, workspaceViewAlias: string);
     isLoaded(): Promise<void>;
     resetState(): void;

package/dist-cms/packages/block/block/workspace/block-element-manager.js

@@ -9,7 +9,7 @@ import { UmbContentValidationToHintsManager, UmbElementWorkspaceDataManager, } f
 import { UmbReadOnlyVariantGuardManager } from '../../../core/utils/index.js';
 import { UmbDataTypeItemRepositoryManager } from '../../../data-type/index.js';
 import { UmbVariantPropertyGuardManager } from '../../../core/property/index.js';
-import { UmbHintContext } from '../../../core/hint/index.js';
+import { UmbViewContext } from '../../../core/view/index.js';
 export class UmbBlockElementManager extends UmbControllerBase {
     //
     #data;
@@ -44,11 +44,8 @@ export class UmbBlockElementManager extends UmbControllerBase {
         this.finishPropertyValueChange = () => {
             this.#data.finishPropertyValueChange();
         };
-        this.hints = new UmbHintContext(this, { viewAlias: workspaceViewAlias });
-        this.hints.inherit();
-        new UmbContentValidationToHintsManager(this, this.structure, this.validation, this.hints, [
-            workspaceViewAlias,
-        ]);
+        this.view = new UmbViewContext(this, workspaceViewAlias);
+        new UmbContentValidationToHintsManager(this, this.structure, this.validation, this.view.hints, []);
         // Ugly, but we just inherit these from the workspace context: [NL]
         this.name = host.name;
         this.getName = () => {
@@ -179,7 +176,7 @@ export class UmbBlockElementManager extends UmbControllerBase {
         this.createPropertyDatasetContext(host, variantId);
         // Provide Validation Context for this view:
         this.validation.provideAt(host);
-        this.hints.provideAt(host);
+        this.view.provideAt(host);
     }
     destroy() {
         this.structure.destroy();

package/dist-cms/packages/block/block/workspace/block-workspace.context.d.ts

@@ -68,6 +68,10 @@ export declare class UmbBlockWorkspaceContext<LayoutDataType extends UmbBlockLay
      */
     setPropertyValue(alias: string, value: unknown): Promise<void>;
     submit(): Promise<void>;
+    /**
+     * Used by Inline Editing Modes as they are inline we want the validation state to be reported instantly, as well they do not have a submit action.
+     */
+    autoReportValidation(): void;
     expose(): void;
     destroy(): void;
 }

package/dist-cms/packages/block/block/workspace/block-workspace.context.js

@@ -109,13 +109,15 @@ export class UmbBlockWorkspaceContext extends UmbSubmittableWorkspaceContextBase
         const manifest = workspaceArgs.manifest;
         this.#entityType = manifest.meta?.entityType;
         window.addEventListener('willchangestate', this.#onWillNavigate);
+        this.content.view.inheritFrom(this.view);
+        this.settings.view.inheritFrom(this.view);
         this.addValidationContext(this.content.validation);
         this.addValidationContext(this.settings.validation);
         this.#retrieveModalContext = this.consumeContext(UMB_MODAL_CONTEXT, (context) => {
             this.#modalContext = context;
             this.#originData = context?.data.originData;
             context?.onSubmit().catch(this.#modalRejected);
-        }).asPromise({ preventTimeout: true });
+        });
         this.#retrieveBlockManager = this.consumeContext(UMB_BLOCK_MANAGER_CONTEXT, (manager) => {
             this.#blockManager = manager;
             this.#gotManager();
@@ -193,9 +195,13 @@ export class UmbBlockWorkspaceContext extends UmbSubmittableWorkspaceContextBase
                     variantId: this.#variantId.getValue(),
                 };
                 this.readOnlyGuard?.addRule(rule);
+                this.content.propertyWriteGuard.addRule({ unique, permitted: false });
+                this.settings.propertyWriteGuard.addRule({ unique, permitted: false });
             }
             else {
                 this.readOnlyGuard?.removeRule(unique);
+                this.content.propertyWriteGuard.removeRule(unique);
+                this.settings.propertyWriteGuard.removeRule(unique);
             }
         }, 'observeIsReadOnly');
         this.observe(this.content.contentTypeId, (contentTypeId) => {
@@ -467,6 +473,13 @@ export class UmbBlockWorkspaceContext extends UmbSubmittableWorkspaceContextBase
         this.content.validation.report();
         this.settings.validation.report();
     }
+    /**
+     * Used by Inline Editing Modes as they are inline we want the validation state to be reported instantly, as well they do not have a submit action.
+     */
+    autoReportValidation() {
+        this.content.validation.autoReport();
+        this.settings.validation.autoReport();
+    }
     expose() {
         const contentKey = this.#layout.value?.contentKey;
         if (!contentKey)

package/dist-cms/packages/block/block/workspace/manifests.js

@@ -21,6 +21,10 @@ export const manifests = [
                 alias: 'Umb.Condition.BlockWorkspaceIsExposed',
                 match: false,
             },
+            {
+                alias: 'Umb.Condition.BlockWorkspaceIsReadOnly',
+                match: false,
+            },
         ],
     },
     {
@@ -42,6 +46,10 @@ export const manifests = [
             {
                 alias: 'Umb.Condition.BlockWorkspaceIsExposed',
             },
+            {
+                alias: 'Umb.Condition.BlockWorkspaceIsReadOnly',
+                match: false,
+            },
         ],
     },
     {

package/dist-cms/packages/block/block/workspace/views/edit/block-workspace-view-edit-content-no-router.element.d.ts

@@ -12,6 +12,7 @@ export declare class UmbBlockWorkspaceViewEditContentNoRouterElement extends Umb
     private _hasRootGroups?;
     private _tabs?;
     private _activeTabKey?;
+    private _hintMap;
     constructor();
     render(): import("lit-html").TemplateResult<1> | undefined;
     static styles: import("lit").CSSResult[];