@umbraco-cms/backoffice 14.0.0--preview006-89e89a2e → 14.0.0--preview006-7bdcb4ac

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

@@ -0,0 +1,208 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UmbBlockEntryContext_instances, _UmbBlockEntryContext_contentUdi, _UmbBlockEntryContext_blockTypeName, _UmbBlockEntryContext_label, _UmbBlockEntryContext_workspacePath, _UmbBlockEntryContext_content, _UmbBlockEntryContext_settings, _UmbBlockEntryContext_observeLayout, _UmbBlockEntryContext_gotManager, _UmbBlockEntryContext_gotEntries, _UmbBlockEntryContext_observeData, _UmbBlockEntryContext_observeBlockType, _UmbBlockEntryContext_observeBlockTypeContentElementName, _UmbBlockEntryContext_observeBlockTypeLabel;
+import { UmbContextBase } from '../../../../libs/class-api/index.js';
+import { UmbObjectState, UmbStringState } from '../../../../libs/observable-api/index.js';
+import { encodeFilePath } from '../../../../shared/utils/index.js';
+import { UMB_CONFIRM_MODAL, UMB_MODAL_MANAGER_CONTEXT } from '../../../core/modal/index.js';
+export class UmbBlockEntryContext extends UmbContextBase {
+    /**
+     * Set the contentUdi of this entry.
+     * @method setContentUdi
+     * @param {string} contentUdi the entry content UDI.
+     * @returns {void}
+     */
+    setContentUdi(contentUdi) {
+        __classPrivateFieldSet(this, _UmbBlockEntryContext_contentUdi, contentUdi, "f");
+        __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeLayout).call(this);
+    }
+    /**
+     * Get the current value of this Blocks label.
+     * @method getLabel
+     * @returns {string}
+     */
+    getLabel() {
+        return __classPrivateFieldGet(this, _UmbBlockEntryContext_label, "f").value;
+    }
+    constructor(host, blockManagerContextToken, blockEntriesContextToken) {
+        super(host, 'UmbBlockEntryContext');
+        _UmbBlockEntryContext_instances.add(this);
+        _UmbBlockEntryContext_contentUdi.set(this, void 0);
+        _UmbBlockEntryContext_blockTypeName.set(this, new UmbStringState(undefined));
+        this.blockTypeName = __classPrivateFieldGet(this, _UmbBlockEntryContext_blockTypeName, "f").asObservable();
+        // TODO: index state + observable?
+        _UmbBlockEntryContext_label.set(this, new UmbStringState(''));
+        this.label = __classPrivateFieldGet(this, _UmbBlockEntryContext_label, "f").asObservable();
+        _UmbBlockEntryContext_workspacePath.set(this, new UmbStringState(undefined));
+        this.workspacePath = __classPrivateFieldGet(this, _UmbBlockEntryContext_workspacePath, "f").asObservable();
+        this.workspaceEditPath = __classPrivateFieldGet(this, _UmbBlockEntryContext_workspacePath, "f").asObservablePart((path) => path ? path + 'edit/' + encodeFilePath(this.getContentUdi() ?? '') : '');
+        this.workspaceEditSettingsPath = __classPrivateFieldGet(this, _UmbBlockEntryContext_workspacePath, "f").asObservablePart((path) => path ? path + 'edit/' + encodeFilePath(this.getContentUdi() ?? '') + '/view/settings' : '');
+        this._blockType = new UmbObjectState(undefined);
+        this.blockType = this._blockType.asObservable();
+        this.blockTypeContentElementTypeKey = this._blockType.asObservablePart((x) => x?.contentElementTypeKey);
+        this.blockTypeSettingsElementTypeKey = this._blockType.asObservablePart((x) => x?.settingsElementTypeKey);
+        this._layout = new UmbObjectState(undefined);
+        this.layout = this._layout.asObservable();
+        /**
+         * @obsolete Use `unique` instead. Cause we will most likely rename this in the future.
+         */
+        this.contentUdi = this._layout.asObservablePart((x) => x?.contentUdi);
+        this.unique = this._layout.asObservablePart((x) => x?.contentUdi);
+        _UmbBlockEntryContext_content.set(this, new UmbObjectState(undefined));
+        this.content = __classPrivateFieldGet(this, _UmbBlockEntryContext_content, "f").asObservable();
+        this.contentTypeKey = __classPrivateFieldGet(this, _UmbBlockEntryContext_content, "f").asObservablePart((x) => x?.contentTypeKey);
+        // TODO: Make sure changes to the Block Content / Settings are reflected back to Manager.
+        _UmbBlockEntryContext_settings.set(this, new UmbObjectState(undefined));
+        this.settings = __classPrivateFieldGet(this, _UmbBlockEntryContext_settings, "f").asObservable();
+        // Consume block manager:
+        this.consumeContext(blockManagerContextToken, (manager) => {
+            this._manager = manager;
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_gotManager).call(this);
+            this._gotManager();
+        });
+        // Consume block entries:
+        this.consumeContext(blockEntriesContextToken, (entries) => {
+            this._entries = entries;
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_gotEntries).call(this);
+            this._gotEntries();
+        });
+        // Observe UDI:
+        this.observe(this.unique, (contentUdi) => {
+            if (!contentUdi)
+                return;
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeData).call(this);
+        });
+        // Observe contentElementTypeKey:
+        this.observe(this.contentTypeKey, (contentElementTypeKey) => {
+            if (!contentElementTypeKey)
+                return;
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeBlockType).call(this);
+        });
+        // Observe blockType:
+        this.observe(this.blockType, (blockType) => {
+            if (!blockType)
+                return;
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeBlockTypeContentElementName).call(this);
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeBlockTypeLabel).call(this);
+        });
+    }
+    getContentUdi() {
+        return this._layout.value?.contentUdi;
+    }
+    // Public methods:
+    //activate
+    edit() { }
+    //editSettings
+    requestDelete() {
+        this.consumeContext(UMB_MODAL_MANAGER_CONTEXT, async (modalManager) => {
+            const modalContext = modalManager.open(UMB_CONFIRM_MODAL, {
+                data: {
+                    headline: `Delete ${this.getLabel()}`,
+                    content: 'Are you sure you want to delete this [INSERT BLOCK TYPE NAME]?',
+                    confirmLabel: 'Delete',
+                    color: 'danger',
+                },
+            });
+            await modalContext.onSubmit();
+            this.delete();
+        });
+    }
+    delete() {
+        if (!this._entries)
+            return;
+        const contentUdi = this._layout.value?.contentUdi;
+        if (!contentUdi)
+            return;
+        this._entries.delete(contentUdi);
+    }
+}
+_UmbBlockEntryContext_contentUdi = new WeakMap(), _UmbBlockEntryContext_blockTypeName = new WeakMap(), _UmbBlockEntryContext_label = new WeakMap(), _UmbBlockEntryContext_workspacePath = new WeakMap(), _UmbBlockEntryContext_content = new WeakMap(), _UmbBlockEntryContext_settings = new WeakMap(), _UmbBlockEntryContext_instances = new WeakSet(), _UmbBlockEntryContext_observeLayout = function _UmbBlockEntryContext_observeLayout() {
+    if (!this._entries || !__classPrivateFieldGet(this, _UmbBlockEntryContext_contentUdi, "f"))
+        return;
+    this.observe(this._entries.layoutOf(__classPrivateFieldGet(this, _UmbBlockEntryContext_contentUdi, "f")), (layout) => {
+        this._layout.setValue(layout);
+    }, 'observeParentLayout');
+    this.observe(this.layout, (layout) => {
+        if (layout) {
+            this._entries?.setOneLayout(layout);
+        }
+    }, 'observeThisLayout');
+}, _UmbBlockEntryContext_gotManager = function _UmbBlockEntryContext_gotManager() {
+    __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeBlockType).call(this);
+    __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeData).call(this);
+}, _UmbBlockEntryContext_gotEntries = function _UmbBlockEntryContext_gotEntries() {
+    __classPrivateFieldGet(this, _UmbBlockEntryContext_instances, "m", _UmbBlockEntryContext_observeLayout).call(this);
+    if (this._entries) {
+        this.observe(this._entries.workspacePath, (workspacePath) => {
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_workspacePath, "f").setValue(workspacePath);
+        }, 'observeWorkspacePath');
+    }
+    else {
+        this.removeControllerByAlias('observeWorkspacePath');
+    }
+}, _UmbBlockEntryContext_observeData = function _UmbBlockEntryContext_observeData() {
+    if (!this._manager)
+        return;
+    const contentUdi = this._layout.value?.contentUdi;
+    if (!contentUdi)
+        return;
+    // observe content:
+    this.observe(this._manager.contentOf(contentUdi), (content) => {
+        __classPrivateFieldGet(this, _UmbBlockEntryContext_content, "f").setValue(content);
+    }, 'observeContent');
+    // observe settings:
+    const settingsUdi = this._layout.value?.settingsUdi;
+    if (settingsUdi) {
+        this.observe(this._manager.contentOf(settingsUdi), (content) => {
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_settings, "f").setValue(content);
+        }, 'observeSettings');
+    }
+}, _UmbBlockEntryContext_observeBlockType = function _UmbBlockEntryContext_observeBlockType() {
+    if (!this._manager)
+        return;
+    const contentTypeKey = __classPrivateFieldGet(this, _UmbBlockEntryContext_content, "f").value?.contentTypeKey;
+    if (!contentTypeKey)
+        return;
+    // observe blockType:
+    this.observe(this._manager.blockTypeOf(contentTypeKey), (blockType) => {
+        this._blockType.setValue(blockType);
+    }, 'observeBlockType');
+}, _UmbBlockEntryContext_observeBlockTypeContentElementName = function _UmbBlockEntryContext_observeBlockTypeContentElementName() {
+    if (!this._manager)
+        return;
+    const contentElementTypeKey = this._blockType.value?.contentElementTypeKey;
+    if (!contentElementTypeKey)
+        return;
+    // observe blockType:
+    this.observe(this._manager.contentTypeNameOf(contentElementTypeKey), (contentTypeName) => {
+        __classPrivateFieldGet(this, _UmbBlockEntryContext_blockTypeName, "f").setValue(contentTypeName);
+    }, 'observeBlockTypeContentElementTypeName');
+}, _UmbBlockEntryContext_observeBlockTypeLabel = function _UmbBlockEntryContext_observeBlockTypeLabel() {
+    if (!this._manager)
+        return;
+    const blockType = this._blockType.value;
+    if (!blockType)
+        return;
+    if (blockType.label) {
+        this.removeControllerByAlias('observeContentTypeName');
+        // Missing part for label syntax, as we need to store the syntax, interpretive it and then set the label: (here we are just parsing the label syntax)
+        __classPrivateFieldGet(this, _UmbBlockEntryContext_label, "f").setValue(blockType.label);
+        return;
+    }
+    else {
+        // 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.blockTypeName, (contentTypeName) => {
+            __classPrivateFieldGet(this, _UmbBlockEntryContext_label, "f").setValue(contentTypeName ?? 'no name');
+        }, 'observeBlockTypeName');
+    }
+};

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

@@ -5,9 +5,16 @@ import { UmbArrayState } from '../../../../libs/observable-api/index.js';
 import type { UmbBlockTypeBaseModel, UmbBlockWorkspaceData } from '../../index.js';
 import 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';
+export type UmbBlockDataObjectModel<LayoutEntryType extends UmbBlockLayoutBaseModel> = {
+    layout: LayoutEntryType;
+    content: UmbBlockDataType;
+    settings?: UmbBlockDataType;
+};
 export declare abstract class UmbBlockManagerContext<BlockType extends UmbBlockTypeBaseModel = UmbBlockTypeBaseModel, BlockLayoutType extends UmbBlockLayoutBaseModel = UmbBlockLayoutBaseModel> extends UmbContextBase<UmbBlockManagerContext> {
     #private;
-    workspacePath: import("rxjs").Observable<string | undefined>;
+    propertyAlias: import("rxjs").Observable<string | undefined>;
+    variantId: import("rxjs").Observable<UmbVariantId | undefined>;
     readonly contentTypes: import("rxjs").Observable<UmbContentTypeModel[]>;
     readonly blockTypes: import("rxjs").Observable<BlockType[]>;
     readonly editorConfiguration: import("rxjs").Observable<UmbPropertyEditorConfigCollection | undefined>;
@@ -29,10 +36,19 @@ export declare abstract class UmbBlockManagerContext<BlockType extends UmbBlockT
     layoutOf(contentUdi: string): import("rxjs").Observable<BlockLayoutType | undefined>;
     contentOf(udi: string): import("rxjs").Observable<UmbBlockDataType | undefined>;
     settingsOf(udi: string): import("rxjs").Observable<UmbBlockDataType | undefined>;
-    setOneLayout(layoutData: BlockLayoutType): UmbArrayState<BlockLayoutType>;
     setOneContent(contentData: UmbBlockDataType): void;
     setOneSettings(settingsData: UmbBlockDataType): void;
-    abstract _createBlock(modalData: UmbBlockWorkspaceData, layoutEntry: Omit<BlockLayoutType, 'contentUdi'>, contentElementTypeKey: string): boolean;
-    createBlock(modalData: UmbBlockWorkspaceData, layoutEntry: Omit<BlockLayoutType, 'contentUdi'>, contentElementTypeKey: string): boolean;
-    deleteBlock(contentUdi: string): void;
+    removeOneContent(contentUdi: string): void;
+    removeOneSettings(settingsUdi: string): void;
+    abstract create(contentElementTypeKey: string, partialLayoutEntry?: Omit<BlockLayoutType, 'contentUdi'>, modalData?: UmbBlockWorkspaceData): UmbBlockDataObjectModel<BlockLayoutType> | undefined;
+    protected createBlockData<ModalDataType extends UmbBlockWorkspaceData>(contentElementTypeKey: string, partialLayoutEntry?: Omit<BlockLayoutType, 'contentUdi'>): {
+        layout: BlockLayoutType;
+        content: {
+            udi: string;
+            contentTypeKey: string;
+        };
+        settings: UmbBlockDataType | undefined;
+    };
+    abstract insert(layoutEntry: BlockLayoutType, content: UmbBlockDataType, settings: UmbBlockDataType | undefined, modalData: UmbBlockWorkspaceData): boolean;
+    protected insertBlockData<ModalDataType extends UmbBlockWorkspaceData>(layoutEntry: BlockLayoutType, content: UmbBlockDataType, settings: UmbBlockDataType | undefined, modalData: ModalDataType): false | undefined;
 }

package/dist-cms/packages/block/block/{manager → context}/block-manager.context.js

@@ -3,15 +3,24 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _UmbBlockManagerContext_instances, _UmbBlockManagerContext_contentTypeRepository, _UmbBlockManagerContext_workspacePath, _UmbBlockManagerContext_contentTypes, _UmbBlockManagerContext_blockTypes, _UmbBlockManagerContext_editorConfiguration, _UmbBlockManagerContext_contents, _UmbBlockManagerContext_settings, _UmbBlockManagerContext_loadContentType;
+var _UmbBlockManagerContext_instances, _UmbBlockManagerContext_contentTypeRepository, _UmbBlockManagerContext_propertyAlias, _UmbBlockManagerContext_variantId, _UmbBlockManagerContext_contentTypes, _UmbBlockManagerContext_blockTypes, _UmbBlockManagerContext_editorConfiguration, _UmbBlockManagerContext_contents, _UmbBlockManagerContext_settings, _UmbBlockManagerContext_loadContentType;
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbArrayState, UmbClassState, UmbStringState } from '../../../../libs/observable-api/index.js';
 import { UmbDocumentTypeDetailRepository } from '../../../documents/document-types/index.js';
 import { buildUdi, getKeyFromUdi } from '../../../../shared/utils/index.js';
-import { UMB_BLOCK_MANAGER_CONTEXT, UMB_BLOCK_WORKSPACE_MODAL } from '../../index.js';
-import { UmbModalRouteRegistrationController } from '../../../core/modal/index.js';
+import { UMB_BLOCK_MANAGER_CONTEXT } from '../../index.js';
 import { UmbId } from '../../../core/id/index.js';
+import { UMB_PROPERTY_CONTEXT } from '../../../core/property/index.js';
 export class UmbBlockManagerContext extends UmbContextBase {
+    // TODO: maybe its bad to consume Property Context, and instead wire this up manually in the property editor? With these: (and one for variant-id..)
+    /*setPropertyAlias(alias: string) {
+        this.#propertyAlias.setValue(alias);
+        console.log('!!!!!manager got alias: ', alias);
+        this.#workspaceModal.setUniquePathValue('propertyAlias', alias);
+    }
+    getPropertyAlias() {
+        this.#propertyAlias.value;
+    }*/
     setEditorConfiguration(configs) {
         __classPrivateFieldGet(this, _UmbBlockManagerContext_editorConfiguration, "f").setValue(configs);
     }
@@ -35,8 +44,10 @@ export class UmbBlockManagerContext extends UmbContextBase {
         _UmbBlockManagerContext_instances.add(this);
         //
         _UmbBlockManagerContext_contentTypeRepository.set(this, new UmbDocumentTypeDetailRepository(this));
-        _UmbBlockManagerContext_workspacePath.set(this, new UmbStringState(undefined));
-        this.workspacePath = __classPrivateFieldGet(this, _UmbBlockManagerContext_workspacePath, "f").asObservable();
+        _UmbBlockManagerContext_propertyAlias.set(this, new UmbStringState(undefined));
+        this.propertyAlias = __classPrivateFieldGet(this, _UmbBlockManagerContext_propertyAlias, "f").asObservable();
+        _UmbBlockManagerContext_variantId.set(this, new UmbClassState(undefined));
+        this.variantId = __classPrivateFieldGet(this, _UmbBlockManagerContext_variantId, "f").asObservable();
         _UmbBlockManagerContext_contentTypes.set(this, new UmbArrayState([], (x) => x.unique));
         this.contentTypes = __classPrivateFieldGet(this, _UmbBlockManagerContext_contentTypes, "f").asObservable();
         _UmbBlockManagerContext_blockTypes.set(this, new UmbArrayState([], (x) => x.contentElementTypeKey));
@@ -49,16 +60,13 @@ export class UmbBlockManagerContext extends UmbContextBase {
         this.contents = __classPrivateFieldGet(this, _UmbBlockManagerContext_contents, "f").asObservable();
         _UmbBlockManagerContext_settings.set(this, new UmbArrayState([], (x) => x.udi));
         this.settings = __classPrivateFieldGet(this, _UmbBlockManagerContext_settings, "f").asObservable();
-        // TODO: This might will need the property alias as part of the URL, to avoid collision if multiple of these Editor on same Node.
-        // IDEA: Make a Workspace registration controller that can be used to register a workspace, which does both edit and create?.
-        new UmbModalRouteRegistrationController(this, UMB_BLOCK_WORKSPACE_MODAL)
-            .addAdditionalPath('block')
-            .onSetup(() => {
-            return { data: { entityType: 'block', preset: {} }, modal: { size: 'medium' } };
-        })
-            .observeRouteBuilder((routeBuilder) => {
-            const newPath = routeBuilder({});
-            __classPrivateFieldGet(this, _UmbBlockManagerContext_workspacePath, "f").setValue(newPath);
+        this.consumeContext(UMB_PROPERTY_CONTEXT, (propertyContext) => {
+            this.observe(propertyContext?.alias, (alias) => {
+                __classPrivateFieldGet(this, _UmbBlockManagerContext_propertyAlias, "f").setValue(alias);
+            }, 'observePropertyAlias');
+            this.observe(propertyContext?.variantId, (variantId) => {
+                __classPrivateFieldGet(this, _UmbBlockManagerContext_variantId, "f").setValue(variantId);
+            }, 'observePropertyVariantId');
         });
     }
     async ensureContentType(unique) {
@@ -88,71 +96,66 @@ export class UmbBlockManagerContext extends UmbContextBase {
     settingsOf(udi) {
         return __classPrivateFieldGet(this, _UmbBlockManagerContext_settings, "f").asObservablePart((source) => source.find((x) => x.udi === udi));
     }
-    setOneLayout(layoutData) {
+    /*setOneLayout(layoutData: BlockLayoutType) {
         return this._layouts.appendOne(layoutData);
-    }
+    }*/
     setOneContent(contentData) {
         __classPrivateFieldGet(this, _UmbBlockManagerContext_contents, "f").appendOne(contentData);
     }
     setOneSettings(settingsData) {
         __classPrivateFieldGet(this, _UmbBlockManagerContext_settings, "f").appendOne(settingsData);
     }
-    createBlock(modalData, layoutEntry, contentElementTypeKey) {
+    removeOneContent(contentUdi) {
+        __classPrivateFieldGet(this, _UmbBlockManagerContext_contents, "f").removeOne(contentUdi);
+    }
+    removeOneSettings(settingsUdi) {
+        __classPrivateFieldGet(this, _UmbBlockManagerContext_settings, "f").removeOne(settingsUdi);
+    }
+    createBlockData(contentElementTypeKey, partialLayoutEntry) {
         // Find block type.
         const blockType = __classPrivateFieldGet(this, _UmbBlockManagerContext_blockTypes, "f").value.find((x) => x.contentElementTypeKey === contentElementTypeKey);
         if (!blockType) {
             throw new Error(`Cannot create block, missing block type for ${contentElementTypeKey}`);
-            return false;
         }
         // Create layout entry:
-        const fullLayoutEntry = {
+        const layout = {
             contentUdi: buildUdi('element', UmbId.new()),
-            ...layoutEntry,
+            ...partialLayoutEntry,
+        };
+        const content = {
+            udi: layout.contentUdi,
+            contentTypeKey: contentElementTypeKey,
         };
+        let settings = undefined;
         if (blockType.settingsElementTypeKey) {
-            fullLayoutEntry.settingsUdi = buildUdi('element', UmbId.new());
-        }
-        if (this._createBlock(modalData, fullLayoutEntry, contentElementTypeKey) === false) {
-            return false;
+            layout.settingsUdi = buildUdi('element', UmbId.new());
+            settings = {
+                udi: layout.settingsUdi,
+                contentTypeKey: blockType.settingsElementTypeKey,
+            };
         }
+        return {
+            layout,
+            content,
+            settings,
+        };
+    }
+    insertBlockData(layoutEntry, content, settings, modalData) {
         // Create content entry:
-        if (fullLayoutEntry.contentUdi) {
-            __classPrivateFieldGet(this, _UmbBlockManagerContext_contents, "f").appendOne({
-                contentTypeKey: contentElementTypeKey,
-                udi: fullLayoutEntry.contentUdi,
-            });
+        if (layoutEntry.contentUdi) {
+            __classPrivateFieldGet(this, _UmbBlockManagerContext_contents, "f").appendOne(content);
         }
         else {
             throw new Error('Cannot create block, missing contentUdi');
             return false;
         }
         //Create settings entry:
-        if (blockType.settingsElementTypeKey) {
-            if (fullLayoutEntry.settingsUdi) {
-                __classPrivateFieldGet(this, _UmbBlockManagerContext_contents, "f").appendOne({
-                    contentTypeKey: blockType.settingsElementTypeKey,
-                    udi: fullLayoutEntry.settingsUdi,
-                });
-            }
-            else {
-                throw new Error('Cannot create block, missing settingsUdi');
-                return false;
-            }
+        if (settings && layoutEntry.settingsUdi) {
+            __classPrivateFieldGet(this, _UmbBlockManagerContext_settings, "f").appendOne(settings);
         }
-        return true;
-    }
-    deleteBlock(contentUdi) {
-        const layout = this._layouts.value.find((x) => x.contentUdi === contentUdi);
-        if (!layout)
-            return;
-        if (layout.settingsUdi) {
-            __classPrivateFieldGet(this, _UmbBlockManagerContext_settings, "f").removeOne(layout.settingsUdi);
-        }
-        this._layouts.removeOne(contentUdi);
-        __classPrivateFieldGet(this, _UmbBlockManagerContext_contents, "f").removeOne(contentUdi);
     }
 }
-_UmbBlockManagerContext_contentTypeRepository = new WeakMap(), _UmbBlockManagerContext_workspacePath = new WeakMap(), _UmbBlockManagerContext_contentTypes = new WeakMap(), _UmbBlockManagerContext_blockTypes = new WeakMap(), _UmbBlockManagerContext_editorConfiguration = new WeakMap(), _UmbBlockManagerContext_contents = new WeakMap(), _UmbBlockManagerContext_settings = new WeakMap(), _UmbBlockManagerContext_instances = new WeakSet(), _UmbBlockManagerContext_loadContentType = async function _UmbBlockManagerContext_loadContentType(unique) {
+_UmbBlockManagerContext_contentTypeRepository = new WeakMap(), _UmbBlockManagerContext_propertyAlias = new WeakMap(), _UmbBlockManagerContext_variantId = new WeakMap(), _UmbBlockManagerContext_contentTypes = new WeakMap(), _UmbBlockManagerContext_blockTypes = new WeakMap(), _UmbBlockManagerContext_editorConfiguration = new WeakMap(), _UmbBlockManagerContext_contents = new WeakMap(), _UmbBlockManagerContext_settings = new WeakMap(), _UmbBlockManagerContext_instances = new WeakSet(), _UmbBlockManagerContext_loadContentType = async function _UmbBlockManagerContext_loadContentType(unique) {
     if (!unique)
         return {};
     const { data } = await __classPrivateFieldGet(this, _UmbBlockManagerContext_contentTypeRepository, "f").requestByUnique(unique);

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

@@ -1 +1,6 @@
-export * from './block-entity.context.js';
+export * from './block-entry.context-token.js';
+export * from './block-entry.context.js';
+export * from './block-entries.context-token.js';
+export * from './block-entries.context.js';
+export * from './block-manager.context-token.js';
+export type * from './block-manager.context.js';

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

@@ -1 +1,5 @@
-export * from './block-entity.context.js';
+export * from './block-entry.context-token.js';
+export * from './block-entry.context.js';
+export * from './block-entries.context-token.js';
+export * from './block-entries.context.js';
+export * from './block-manager.context-token.js';

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

@@ -1,6 +1,5 @@
 export * from './conditions/index.js';
 export * from './context/index.js';
-export * from './manager/index.js';
 export * from './modals/index.js';
 export * from './types.js';
 export * from './workspace/index.js';

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

@@ -1,6 +1,5 @@
 export * from './conditions/index.js';
 export * from './context/index.js';
-export * from './manager/index.js';
 export * from './modals/index.js';
 export * from './types.js';
 export * from './workspace/index.js';

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

@@ -2,7 +2,6 @@ import { UmbLitElement } from '../../../core/lit-element/index.js';
 export declare class UmbBlockWorkspaceEditorElement extends UmbLitElement {
     #private;
     workspaceAlias?: string;
-    constructor();
     render(): "" | import("lit-html").TemplateResult<1>;
     static styles: import("@lit/reactive-element/css-tag.js").CSSResult[];
 }

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

@@ -4,31 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var _UmbBlockWorkspaceEditorElement_workspaceContext;
-import { UMB_BLOCK_WORKSPACE_CONTEXT } from './block-workspace.context-token.js';
 import { UmbTextStyles } from '../../../../shared/style/index.js';
 import { customElement, css, html, property } from '../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../core/lit-element/index.js';
 let UmbBlockWorkspaceEditorElement = class UmbBlockWorkspaceEditorElement extends UmbLitElement {
     constructor() {
-        super();
+        super(...arguments);
         //
         _UmbBlockWorkspaceEditorElement_workspaceContext.set(this, void 0);
-        this.consumeContext(UMB_BLOCK_WORKSPACE_CONTEXT, (instance) => {
-            __classPrivateFieldSet(this, _UmbBlockWorkspaceEditorElement_workspaceContext, instance, "f");
-            __classPrivateFieldGet(this, _UmbBlockWorkspaceEditorElement_workspaceContext, "f")?.content.createPropertyDatasetContext(this);
-        });
     }
     render() {
         return this.workspaceAlias