@umbraco-cms/backoffice 15.2.2 → 15.3.0-rc

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

@@ -2,11 +2,14 @@ import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbBooleanState, UmbClassState, UmbNumberState, UmbObjectState, UmbStringState, mergeObservables, observeMultiple, } from '../../../../libs/observable-api/index.js';
 import { encodeFilePath, UmbReadOnlyVariantStateManager } from '../../../core/utils/index.js';
 import { umbConfirmModal } from '../../../core/modal/index.js';
+import { UmbLocalizationController } from '../../../../libs/localization-api/index.js';
+import { UmbRoutePathAddendumContext } from '../../../core/router/index.js';
 import { UmbVariantId } from '../../../core/variant/index.js';
 import { UmbUfmVirtualRenderController } from '../../../ufm/index.js';
-import { UmbRoutePathAddendumContext } from '../../../core/router/index.js';
 export class UmbBlockEntryContext extends UmbContextBase {
     #contentKey;
+    #unsupported;
+    #localize;
     #pathAddendum;
     #variantId;
     #hasExpose;
@@ -117,15 +120,7 @@ export class UmbBlockEntryContext extends UmbContextBase {
     async contentValues() {
         await this.#contentStructurePromise;
         if (!this.#contentValuesObservable) {
-            this.#contentValuesObservable = mergeObservables([this._contentValueArray, this.#contentStructure.contentTypeProperties, this._variantId], ([propertyValues, properties, variantId]) => {
-                if (!propertyValues || !properties || !variantId)
-                    return;
-                return properties.reduce((acc, property) => {
-                    const propertyVariantId = this.#createPropertyVariantId(property, variantId);
-                    acc[property.alias] = propertyValues.find((x) => x.alias === property.alias && propertyVariantId.compare(x))?.value;
-                    return acc;
-                }, {});
-            });
+            this.#contentValuesObservable = mergeObservables([this._contentValueArray, this.#contentStructure.contentTypeProperties, this._variantId], this.#propertyValuesToObjectCallback);
         }
         return this.#contentValuesObservable;
     }
@@ -141,17 +136,11 @@ export class UmbBlockEntryContext extends UmbContextBase {
     async settingsValues() {
         await this.#settingsStructurePromise;
         if (!this.#settingsValuesObservable) {
-            this.#settingsValuesObservable = mergeObservables([this._settingsValueArray, this.#settingsStructure.contentTypeProperties, this._variantId], ([propertyValues, properties, variantId]) => {
-                if (!propertyValues || !properties || !variantId)
-                    return;
-                return properties.reduce((acc, property) => {
-                    acc[property.alias] = propertyValues.find((x) => this.#createPropertyVariantId(property, variantId).compare(x))?.value;
-                    return acc;
-                }, {});
-            });
+            this.#settingsValuesObservable = mergeObservables([this._settingsValueArray, this.#settingsStructure.contentTypeProperties, this._variantId], this.#propertyValuesToObjectCallback);
         }
         return this.#settingsValuesObservable;
     }
+    #propertyValuesToObjectCallback;
     /**
      * Get the settings of the block.
      * @returns {UmbBlockDataModel | undefined} - the settings of the block.
@@ -161,6 +150,9 @@ export class UmbBlockEntryContext extends UmbContextBase {
     }
     constructor(host, blockManagerContextToken, blockEntriesContextToken) {
         super(host, 'UmbBlockEntryContext');
+        this.#unsupported = new UmbBooleanState(undefined);
+        this.unsupported = this.#unsupported.asObservable();
+        this.#localize = new UmbLocalizationController(this);
         this.#pathAddendum = new UmbRoutePathAddendumContext(this);
         this.#variantId = new UmbClassState(undefined);
         this._variantId = this.#variantId.asObservable();
@@ -217,6 +209,15 @@ export class UmbBlockEntryContext extends UmbContextBase {
         //public readonly settings = this.#settings.asObservable();
         this._settingsValueArray = this.#settings.asObservablePart((x) => x?.values);
         this.settingsDataContentTypeKey = this.#settings.asObservablePart((x) => x ? (x.contentTypeKey ?? undefined) : null);
+        this.#propertyValuesToObjectCallback = ([propertyValues, properties, variantId]) => {
+            if (!propertyValues || !properties || !variantId)
+                return;
+            return properties.reduce((acc, property) => {
+                const propertyVariantId = this.#createPropertyVariantId(property, variantId);
+                acc[property.alias] = propertyValues.find((x) => x.alias === property.alias && propertyVariantId.compare(x))?.value;
+                return acc;
+            }, {});
+        };
         this.observe(this.label, (label) => {
             this.#labelRender.markdown = label;
         });
@@ -276,12 +277,12 @@ export class UmbBlockEntryContext extends UmbContextBase {
                 // We do not need to remove the settings if configuration is gone, cause another observation handles this. [NL]
             }
         }, null);
-        this.observe(observeMultiple([this.settingsKey, this.blockType]), ([settingsKey, blockType]) => {
+        this.observe(observeMultiple([this.settingsKey, this.blockType]), async ([settingsKey, blockType]) => {
             if (!this.#contentKey || settingsKey === undefined || !blockType)
                 return;
             if (settingsKey == null && blockType.settingsElementTypeKey) {
                 // We have a settings ElementType in config but not in data, so lets create the scaffold for that: [NL]
-                const settingsData = this._manager.createBlockSettingsData(blockType.contentElementTypeKey); // Yes its on purpose we use the contentElementTypeKey here, as this is our identifier for a BlockType. [NL]
+                const settingsData = await this._manager.createBlockSettingsData(blockType.contentElementTypeKey); // Yes its on purpose we use the contentElementTypeKey here, as this is our identifier for a BlockType. [NL]
                 this._manager?.setOneSettings(settingsData);
                 this._layout.update({ settingsKey: settingsData.key });
             }
@@ -356,20 +357,19 @@ export class UmbBlockEntryContext extends UmbContextBase {
     #gotEntries() {
         this.#updateCreatePaths();
         this.#observeLayout();
-        if (this._entries) {
-            this.observe(this._entries.workspacePath, (workspacePath) => {
-                this.#workspacePath.setValue(workspacePath);
-            }, 'observeWorkspacePath');
-        }
-        else {
-            this.removeUmbControllerByAlias('observeWorkspacePath');
-        }
+        this.observe(this._entries?.workspacePath, (workspacePath) => {
+            this.#workspacePath.setValue(workspacePath);
+        }, 'observeWorkspacePath');
     }
     #observeContentData() {
         if (!this._manager || !this.#contentKey)
             return;
         // observe content:
         this.observe(this._manager.contentOf(this.#contentKey), (content) => {
+            if (this.#unsupported.getValue() !== true) {
+                // If we could not find content, then we do not know the contentTypeKey and then the content is broken. [NL]
+                this.#unsupported.setValue(!content);
+            }
             this.#content.setValue(content);
         }, 'observeContent');
     }
@@ -390,7 +390,7 @@ export class UmbBlockEntryContext extends UmbContextBase {
         if (!this.#contentStructure) {
             throw new Error('No contentStructure found');
         }
-        // observe blockType:
+        // observe variantId:
         this.observe(observeMultiple([
             this._manager.variantId,
             this.#contentStructure?.ownerContentTypeObservablePart((x) => x?.variesByCulture),
@@ -400,7 +400,7 @@ export class UmbBlockEntryContext extends UmbContextBase {
                 return;
             this.#variantId.setValue(variantId.toVariant(variesByCulture, variesBySegment));
             this.#gotVariantId();
-        }, 'observeBlockType');
+        }, 'observeVariantId');
     }
     #observeReadOnlyState() {
         if (!this._manager)
@@ -431,6 +431,10 @@ export class UmbBlockEntryContext extends UmbContextBase {
         // observe blockType:
         this.#contentStructure = this._manager.getStructure(contentTypeKey);
         this.#contentStructurePromiseResolve?.();
+        if (!this.#contentStructure) {
+            // If we got no content structure, then this is element type did not load and there for it is not supported any longer.
+            this.#unsupported.setValue(true);
+        }
         this.observe(this.#contentStructure?.ownerContentType, (contentType) => {
             /**
              * currently only using:
@@ -459,6 +463,10 @@ export class UmbBlockEntryContext extends UmbContextBase {
         // observe blockType:
         this.observe(this._manager.blockTypeOf(contentTypeKey), (blockType) => {
             this._blockType.setValue(blockType);
+            if (!blockType) {
+                // If the block type is undefined, then we do not have this Block Type and the Block is then unsupported. [NL]
+                this.#unsupported.setValue(true);
+            }
         }, 'observeBlockType');
     }
     #observeBlockTypeLabel() {
@@ -477,7 +485,7 @@ export class UmbBlockEntryContext extends UmbContextBase {
             // TODO: Maybe this could be skipped if we had a fallback label which was set to get the content element type name?
             // Get the name of the content element type for label:
             this.observe(this.contentElementTypeName, (contentTypeName) => {
-                this.#label.setValue(contentTypeName ?? 'no name');
+                this.#label.setValue(this.#localize.string(contentTypeName) || 'no name');
             }, 'observeContentTypeName');
         }
     }
@@ -499,11 +507,10 @@ export class UmbBlockEntryContext extends UmbContextBase {
     }
     async requestDelete() {
         const blockName = this.getName();
-        // TODO: Localizations missing [NL]
         await umbConfirmModal(this, {
-            headline: `Delete ${blockName}`,
-            content: `Are you sure you want to delete this ${blockName}?`,
-            confirmLabel: 'Delete',
+            headline: this.#localize.term('blockEditor_confirmDeleteBlockTitle', blockName),
+            content: this.#localize.term('blockEditor_confirmDeleteBlockMessage', blockName),
+            confirmLabel: this.#localize.term('general_delete'),
             color: 'danger',
         });
         this.delete();

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

@@ -5,7 +5,7 @@ import type { UmbControllerHost } from '../../../../libs/controller-api/index.js
 import { UmbArrayState, UmbBooleanState, UmbClassState, type MappingFunction } from '../../../../libs/observable-api/index.js';
 import { UmbContentTypeStructureManager, type UmbContentTypeModel } from '../../../core/content-type/index.js';
 import type { UmbPropertyEditorConfigCollection } from '../../../core/property-editor/index.js';
-import type { UmbVariantId } from '../../../core/variant/index.js';
+import { UmbVariantId } from '../../../core/variant/index.js';
 import type { UmbBlockTypeBaseModel } from '../../block-type/index.js';
 import { UmbReadOnlyVariantStateManager } from '../../../core/utils/index.js';
 export type UmbBlockDataObjectModel<LayoutEntryType extends UmbBlockLayoutBaseModel> = {
@@ -107,26 +107,33 @@ export declare abstract class UmbBlockManagerContext<BlockType extends UmbBlockT
     setOneSettingsProperty(key: string, propertyAlias: string, value: unknown): void;
     contentProperty(key: string, propertyAlias: string): void;
     settingsProperty(key: string, propertyAlias: string): void;
+    /**
+     * @deprecated Use `createWithPresets` instead. Which is Async. Will be removed in v.17
+     * @param contentElementTypeKey
+     * @param partialLayoutEntry
+     * @param originData
+     */
     abstract create(contentElementTypeKey: string, partialLayoutEntry?: Omit<BlockLayoutType, 'contentKey'>, originData?: BlockOriginDataType): UmbBlockDataObjectModel<BlockLayoutType> | undefined;
-    createBlockSettingsData(contentElementTypeKey: string): {
+    abstract createWithPresets(contentElementTypeKey: string, partialLayoutEntry?: Omit<BlockLayoutType, 'contentKey'>, originData?: BlockOriginDataType): Promise<UmbBlockDataObjectModel<BlockLayoutType> | undefined>;
+    createBlockSettingsData(contentElementTypeKey: string): Promise<{
         key: string;
         contentTypeKey: string;
         values: never[];
-    };
-    protected _createBlockElementData(key: string, elementTypeKey: string): {
+    }>;
+    protected _createBlockElementData(key: string, contentTypeKey: string): Promise<{
         key: string;
         contentTypeKey: string;
-        values: never[];
-    };
-    protected _createBlockData(contentElementTypeKey: string, partialLayoutEntry?: Omit<BlockLayoutType, 'contentKey'>): {
+        values: import("../../../core/content/index.js").UmbElementValueModel<unknown>[];
+    }>;
+    protected _createBlockData(contentElementTypeKey: string, partialLayoutEntry?: Omit<BlockLayoutType, 'contentKey'>): Promise<{
         layout: BlockLayoutType;
         content: {
             key: string;
             contentTypeKey: string;
-            values: never[];
+            values: import("../../../core/content/index.js").UmbElementValueModel<unknown>[];
         };
         settings: UmbBlockDataModel | undefined;
-    };
+    }>;
     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 removeBlockKey(contentKey: string): void;

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

@@ -4,7 +4,11 @@ import { UmbArrayState, UmbBooleanState, UmbClassState, UmbStringState, mergeObs
 import { UmbDocumentTypeDetailRepository } from '../../../documents/document-types/index.js';
 import { UmbContentTypeStructureManager } from '../../../core/content-type/index.js';
 import { UmbId } from '../../../core/id/index.js';
+import { UmbVariantId } from '../../../core/variant/index.js';
 import { UmbReadOnlyVariantStateManager } from '../../../core/utils/index.js';
+import { UmbPropertyValuePresetVariantBuilderController, } from '../../../core/property/index.js';
+import { UMB_APP_LANGUAGE_CONTEXT } from '../../../language/index.js';
+import { UmbDataTypeDetailRepository } from '../../../data-type/index.js';
 export class UmbBlockManagerContext extends UmbContextBase {
     get contentTypesLoaded() {
         return Promise.all(this.#contentTypeRequests);
@@ -254,7 +258,7 @@ export class UmbBlockManagerContext extends UmbContextBase {
     settingsProperty(key, propertyAlias) {
         this.#settings.asObservablePart((source) => source.find((x) => x.key === key)?.values?.find((values) => values.alias === propertyAlias)?.value);
     }
-    createBlockSettingsData(contentElementTypeKey) {
+    async createBlockSettingsData(contentElementTypeKey) {
         const blockType = this.#blockTypes.value.find((x) => x.contentElementTypeKey === contentElementTypeKey);
         if (!blockType) {
             throw new Error(`Cannot create block settings, missing block type for ${contentElementTypeKey}`);
@@ -262,20 +266,64 @@ export class UmbBlockManagerContext extends UmbContextBase {
         if (!blockType.settingsElementTypeKey) {
             throw new Error(`Cannot create block settings, missing settings element type for ${contentElementTypeKey}`);
         }
+        // TODO: Handle presets here [NL]
         return {
             key: UmbId.new(),
             contentTypeKey: blockType.settingsElementTypeKey,
             values: [],
         };
     }
-    _createBlockElementData(key, elementTypeKey) {
+    async _createBlockElementData(key, contentTypeKey) {
+        //
+        const appLanguage = await this.getContext(UMB_APP_LANGUAGE_CONTEXT);
+        const contentStructure = this.getStructure(contentTypeKey);
+        if (!contentStructure) {
+            throw new Error(`Cannot create Preset for Block, missing content structure for ${contentTypeKey}`);
+        }
+        // Set culture and segment for all values:
+        const cutlures = contentStructure.variesByCulture ? await appLanguage.getCultures() : [];
+        if (cutlures.length === 0) {
+            throw new Error('Could not retrieve app cultures.');
+        }
+        // TODO: Receive the segments from somewhere. [NL]
+        const segments = contentStructure.variesBySegment ? [] : undefined;
+        const repo = new UmbDataTypeDetailRepository(this);
+        const propertyTypes = await contentStructure.getContentTypeProperties();
+        const valueDefinitions = await Promise.all(propertyTypes.map(async (property) => {
+            // TODO: Implement caching for data-type requests. [NL]
+            const dataType = (await repo.requestByUnique(property.dataType.unique)).data;
+            // This means if its not loaded this will never resolve and the error below will never happen.
+            if (!dataType) {
+                throw new Error(`DataType of "${property.dataType.unique}" not found.`);
+            }
+            if (!dataType.editorUiAlias) {
+                throw new Error(`DataType of "${property.dataType.unique}" did not have a editorUiAlias.`);
+            }
+            return {
+                alias: property.alias,
+                propertyEditorUiAlias: dataType.editorUiAlias,
+                propertyEditorSchemaAlias: dataType.editorAlias,
+                config: dataType.values,
+                typeArgs: {
+                    variesByCulture: property.variesByCulture,
+                    variesBySegment: property.variesBySegment,
+                },
+            };
+        }));
+        const controller = new UmbPropertyValuePresetVariantBuilderController(this);
+        controller.setCultures(cutlures);
+        if (segments) {
+            controller.setSegments(segments);
+        }
+        const values = await controller.create(valueDefinitions);
+        // Set culture and segment for all values:
         return {
-            key: key,
-            contentTypeKey: elementTypeKey,
-            values: [],
+            key,
+            contentTypeKey,
+            values,
         };
     }
-    _createBlockData(contentElementTypeKey, partialLayoutEntry) {
+    async _createBlockData(contentElementTypeKey, partialLayoutEntry) {
         // Find block type.
         const blockType = this.#blockTypes.value.find((x) => x.contentElementTypeKey === contentElementTypeKey);
         if (!blockType) {
@@ -286,11 +334,11 @@ export class UmbBlockManagerContext extends UmbContextBase {
             contentKey: UmbId.new(),
             ...partialLayoutEntry,
         };
-        const content = this._createBlockElementData(layout.contentKey, contentElementTypeKey);
+        const content = await this._createBlockElementData(layout.contentKey, contentElementTypeKey);
         let settings = undefined;
         if (blockType.settingsElementTypeKey) {
             layout.settingsKey = UmbId.new();
-            settings = this._createBlockElementData(layout.settingsKey, blockType.settingsElementTypeKey);
+            settings = await this._createBlockElementData(layout.settingsKey, blockType.settingsElementTypeKey);
         }
         return {
             layout,
@@ -313,18 +361,33 @@ export class UmbBlockManagerContext extends UmbContextBase {
             this.#settings.appendOne(settings);
         }
         // Expose inserted block:
-        this.contentTypesLoaded.then(() => {
-            const contentStructure = this.getStructure(content.contentTypeKey);
-            if (!contentStructure) {
-                throw new Error(`Cannot expose block, missing content structure for ${content.contentTypeKey}`);
-            }
-            const variantId = this.getVariantId();
-            if (!variantId) {
-                throw new Error(`Cannot expose block, missing variantId`);
-            }
-            const blockVariantId = variantId.toVariant(contentStructure.getVariesByCulture(), contentStructure.getVariesBySegment());
-            this.setOneExpose(content.key, blockVariantId);
-        });
+        this.#setInitialBlockExpose(content);
+    }
+    async #setInitialBlockExpose(content) {
+        await this.contentTypesLoaded;
+        const contentStructure = this.getStructure(content.contentTypeKey);
+        if (!contentStructure) {
+            throw new Error(`Cannot expose block, missing content structure for ${content.contentTypeKey}`);
+        }
+        const variantId = this.getVariantId();
+        if (!variantId) {
+            throw new Error(`Cannot expose block, missing variantId`);
+        }
+        const varyByCulture = contentStructure.getVariesByCulture();
+        const varyBySegment = contentStructure.getVariesBySegment();
+        const blockVariantId = variantId.toVariant(varyByCulture, varyBySegment);
+        this.setOneExpose(content.key, blockVariantId);
+        if (varyByCulture) {
+            // get all mandatory cultures:
+            const appLanguageContext = await this.getContext(UMB_APP_LANGUAGE_CONTEXT);
+            const mandatoryLanguages = await appLanguageContext.getMandatoryLanguages();
+            mandatoryLanguages.forEach((x) => {
+                // No need to insert the same expose twice:
+                if (blockVariantId.culture !== x.unique) {
+                    this.setOneExpose(content.key, new UmbVariantId(x.unique));
+                }
+            });
+        }
     }
     removeBlockKey(contentKey) {
         this.#contents.removeOne(contentKey);

package/dist-cms/packages/block/block/validation/block-element-data-validation-path-translator.controller.js

@@ -12,7 +12,7 @@ export class UmbBlockElementDataValidationPathTranslator extends UmbAbstractArra
         const data = this._context.getTranslationData();
         const entry = data[this.#propertyName][index];
         if (!entry || !entry.key) {
-            console.error('block did not have key', this.#propertyName, index, data);
+            console.error('block did not have key', `${this.#propertyName}[${index}]`, entry);
             return false;
         }
         return entry;

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

@@ -92,10 +92,7 @@ export class UmbBlockElementManager extends UmbControllerBase {
         return this.getData()?.contentTypeKey;
     }
     #createPropertyVariantId(property, variantId) {
-        return UmbVariantId.Create({
-            culture: property.variesByCulture ? variantId.culture : null,
-            segment: property.variesBySegment ? variantId.segment : null,
-        });
+        return variantId.toVariant(property.variesByCulture, property.variesBySegment);
     }
     // We will implement propertyAlias in the future, when implementing Varying Blocks. [NL]
     async propertyVariantId(propertyAlias) {
@@ -133,6 +130,7 @@ export class UmbBlockElementManager extends UmbControllerBase {
         if (!property) {
             throw new Error(`Property alias "${alias}" not found.`);
         }
+        // TODO: I think we should await this in the same way as we do for Content Detail Workspace Context. [NL]
         const editorAlias = this.#dataTypeSchemaAliasMap.get(property.dataType.unique);
         if (!editorAlias) {
             throw new Error(`Editor Alias of "${property.dataType.unique}" not found.`);

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

@@ -81,58 +81,7 @@ export class UmbBlockWorkspaceContext extends UmbSubmittableWorkspaceContextBase
         }).asPromise();
         this.#retrieveBlockManager = this.consumeContext(UMB_BLOCK_MANAGER_CONTEXT, (manager) => {
             this.#blockManager = manager;
-            this.observe(manager.liveEditingMode, (liveEditingMode) => {
-                this.#liveEditingMode = liveEditingMode ?? false;
-            }, 'observeLiveEditingMode');
-            this.observe(observeMultiple([
-                manager.variantId,
-                this.content.structure.variesByCulture,
-                this.content.structure.variesBySegment,
-            ]), ([variantId, variesByCulture, variesBySegment]) => {
-                if (!variantId || variesByCulture === undefined || variesBySegment === undefined)
-                    return;
-                if (!variesBySegment && !variesByCulture) {
-                    variantId = UmbVariantId.CreateInvariant();
-                }
-                else if (!variesBySegment) {
-                    variantId = variantId.toSegmentInvariant();
-                }
-                else if (!variesByCulture) {
-                    variantId = variantId.toCultureInvariant();
-                }
-                this.#variantId.setValue(variantId);
-            }, 'observeVariantIds');
-            this.removeUmbControllerByAlias('observeHasExpose');
-            this.observe(observeMultiple([this.contentKey, this.variantId]), ([contentKey, variantId]) => {
-                if (!contentKey || !variantId)
-                    return;
-                this.observe(manager.hasExposeOf(contentKey, variantId), (exposed) => {
-                    this.#exposed.setValue(exposed);
-                }, 'observeHasExpose');
-            }, 'observeContentKeyAndVariantId');
-            this.observe(observeMultiple([manager.readOnlyState.isReadOnly, this.variantId]), ([isReadOnly, variantId]) => {
-                const unique = 'UMB_BLOCK_MANAGER_CONTEXT';
-                if (variantId === undefined)
-                    return;
-                if (isReadOnly) {
-                    const state = {
-                        unique,
-                        variantId,
-                        message: '',
-                    };
-                    this.readOnlyState?.addState(state);
-                }
-                else {
-                    this.readOnlyState?.removeState(unique);
-                }
-            }, 'observeIsReadOnly');
-            this.observe(this.content.contentTypeId, (contentTypeId) => {
-                this.observe(contentTypeId ? manager.blockTypeOf(contentTypeId) : undefined, (blockType) => {
-                    if (blockType?.editorSize) {
-                        this.setEditorSize(blockType.editorSize);
-                    }
-                }, 'observeBlockType');
-            }, 'observeContentTypeId');
+            this.#gotManager();
         });
         this.#retrieveBlockEntries = this.consumeContext(UMB_BLOCK_ENTRIES_CONTEXT, (context) => {
             this.#blockEntries = context;
@@ -164,6 +113,63 @@ export class UmbBlockWorkspaceContext extends UmbSubmittableWorkspaceContextBase
             },
         ]);
     }
+    #gotManager() {
+        if (!this.#blockManager)
+            return;
+        const manager = this.#blockManager;
+        this.observe(manager.liveEditingMode, (liveEditingMode) => {
+            this.#liveEditingMode = liveEditingMode ?? false;
+        }, 'observeLiveEditingMode');
+        this.observe(observeMultiple([
+            manager.variantId,
+            this.content.structure.variesByCulture,
+            this.content.structure.variesBySegment,
+        ]), ([variantId, variesByCulture, variesBySegment]) => {
+            if (!variantId || variesByCulture === undefined || variesBySegment === undefined)
+                return;
+            if (!variesBySegment && !variesByCulture) {
+                variantId = UmbVariantId.CreateInvariant();
+            }
+            else if (!variesBySegment) {
+                variantId = variantId.toSegmentInvariant();
+            }
+            else if (!variesByCulture) {
+                variantId = variantId.toCultureInvariant();
+            }
+            this.#variantId.setValue(variantId);
+        }, 'observeVariantIds');
+        this.removeUmbControllerByAlias('observeHasExpose');
+        this.observe(observeMultiple([this.contentKey, this.variantId]), ([contentKey, variantId]) => {
+            if (!contentKey || !variantId)
+                return;
+            this.observe(manager.hasExposeOf(contentKey, variantId), (exposed) => {
+                this.#exposed.setValue(exposed);
+            }, 'observeHasExpose');
+        }, 'observeContentKeyAndVariantId');
+        this.observe(observeMultiple([manager.readOnlyState.isReadOnly, this.variantId]), ([isReadOnly, variantId]) => {
+            const unique = 'UMB_BLOCK_MANAGER_CONTEXT';
+            if (variantId === undefined)
+                return;
+            if (isReadOnly) {
+                const state = {
+                    unique,
+                    variantId,
+                    message: '',
+                };
+                this.readOnlyState?.addState(state);
+            }
+            else {
+                this.readOnlyState?.removeState(unique);
+            }
+        }, 'observeIsReadOnly');
+        this.observe(this.content.contentTypeId, (contentTypeId) => {
+            this.observe(contentTypeId ? manager.blockTypeOf(contentTypeId) : undefined, (blockType) => {
+                if (blockType?.editorSize) {
+                    this.setEditorSize(blockType.editorSize);
+                }
+            }, 'observeBlockType');
+        }, 'observeContentTypeId');
+    }
     setEditorSize(editorSize) {
         this.#modalContext?.setModalSize(editorSize);
     }

package/dist-cms/packages/block/block-custom-view/types.d.ts

@@ -21,6 +21,7 @@ export interface UmbBlockEditorCustomViewProperties<LayoutType extends UmbBlockL
     settings?: UmbBlockDataType;
     contentInvalid?: boolean;
     settingsInvalid?: boolean;
+    unsupported?: boolean;
     unpublished?: boolean;
 }
 export interface UmbBlockEditorCustomViewElement<LayoutType extends UmbBlockLayoutBaseModel = UmbBlockLayoutBaseModel, BlockType extends UmbBlockTypeBaseModel = UmbBlockTypeBaseModel> extends UmbBlockEditorCustomViewProperties<LayoutType, BlockType>, HTMLElement {

package/dist-cms/packages/block/block-grid/components/block-grid-block/block-grid-block.element.js

@@ -21,7 +21,7 @@ let UmbBlockGridBlockElement = class UmbBlockGridBlockElement extends UmbLitElem
 						><umb-localize key="blockEditor_notExposedLabel"></umb-localize
 					></uui-tag>`
             : nothing}
-			<umb-block-grid-areas-container slot="areas"></umb-block-grid-areas-container>
+			<umb-block-grid-areas-container slot="areas" draggable="false"></umb-block-grid-areas-container>
 		</umb-ref-grid-block>`;
     }
     static { this.styles = [

package/dist-cms/packages/block/block-grid/components/block-grid-block-inline/block-grid-block-inline.element.js

@@ -136,12 +136,12 @@ let UmbBlockGridBlockInlineElement = class UmbBlockGridBlockInlineElement extend
 			></uui-button>`;
         }
         else {
-            return html `<div id="inside">
+            return html `<div id="inside" draggable="false">
 				<umb-property-type-based-property
 					.property=${this._inlineProperty}
 					.dataPath=${this._inlinePropertyDataPath ?? ''}
 					slot="areas"></umb-property-type-based-property>
-				<umb-block-grid-areas-container slot="areas"></umb-block-grid-areas-container>
+				<umb-block-grid-areas-container slot="areas" draggable="false"></umb-block-grid-areas-container>
 			</div>`;
         }
     }

package/dist-cms/packages/block/block-grid/components/block-grid-block-unsupported/block-grid-block-unsupported.element.d.ts

@@ -0,0 +1,14 @@
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import '../block-grid-areas-container/index.js';
+import '../ref-grid-block/index.js';
+export declare class UmbBlockGridBlockUnsupportedElement extends UmbLitElement {
+    #private;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+export default UmbBlockGridBlockUnsupportedElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-block-grid-block-unsupported': UmbBlockGridBlockUnsupportedElement;
+    }
+}