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

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

@@ -1,19 +1,62 @@
 import { UmbBlockInsertedEvent } from '../events/block-inserted.event.js';
+import { UMB_BLOCK_TRANSFER_TO_ELEMENT_LIBRARY_MODAL } from '../modals/transfer-to-element-library/transfer-to-element-library-modal.token.js';
 import { UMB_BLOCK_CONTENT_DATA_PATH_PROPERTY_NAME, UMB_BLOCK_SETTINGS_DATA_PATH_PROPERTY_NAME } from '../constants.js';
+import { umbBlockExposeSortCompare } from '../utils/block-expose-sort-compare.function.js';
+import { umbGetBlockedTransferVariants, umbResolveBlockTransferCultures, } from '../utils/block-transfer-variants.function.js';
+import { getExternalContentFailureReason } from '../utils/get-external-content-failure-reason.function.js';
 import { UMB_BLOCK_MANAGER_CONTEXT } from './block-manager.context-token.js';
+import { findExternalContentVariant, } from './block-manager-external-content.function.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbArrayState, UmbBooleanState, UmbClassState, UmbStringState, mergeObservables, } from '../../../../libs/observable-api/index.js';
 import { UmbDocumentTypeDetailRepository } from '../../../documents/document-types/index.js';
 import { UmbContentTypeStructureManager } from '../../../content/content-type/index.js';
 import { UmbId } from '../../../core/id/index.js';
 import { UmbVariantId } from '../../../core/variant/index.js';
-import { UmbDeprecation, UmbReadOnlyVariantGuardManager } from '../../../core/utils/index.js';
-import { UmbPropertyValuePresetVariantBuilderController, } from '../../../core/property/index.js';
+import { escapeHTML, UmbDeprecation, UmbReadOnlyVariantGuardManager } from '../../../core/utils/index.js';
+import { UmbPropertyValueFlatMapperController, UmbPropertyValuePresetVariantBuilderController, } from '../../../core/property/index.js';
 import { UMB_APP_LANGUAGE_CONTEXT } from '../../../language/index.js';
+import { UMB_CURRENT_USER_CONTEXT } from '../../../user/current-user/index.js';
 import { UmbDataTypeDetailRepository } from '../../../data-type/index.js';
+import { UmbElementDetailRepository, UmbElementPublishingRepository, UmbElementValidationRepository, } from '../../../elements/index.js';
+import { UmbLocalizationController } from '../../../../libs/localization-api/index.js';
+import { UMB_MODAL_MANAGER_CONTEXT, umbConfirmModal, umbInfoModal } from '../../../core/modal/index.js';
+import { UmbRepositoryDetailsManager } from '../../../core/repository/index.js';
+import { UmbApiError, apiErrorWasNotified } from '../../../core/resources/index.js';
 import { UMB_VALIDATION_CONTEXT, UmbValidationCleanUpByUniqueManager, } from '../../../core/validation/index.js';
 const UMB_CONTENT_VALIDATION_CLEAN_UP_ALIAS = Symbol();
 const UMB_SETTINGS_VALIDATION_CLEAN_UP_ALIAS = Symbol();
+const isPublishValidationError = (error) => error.status === 400 &&
+    (Object.keys(error.problemDetails.errors ?? {}).length > 0 || 'invalidProperties' in error.problemDetails);
+/**
+ * Maps a resolved Element to the block data shape used for local and external block content alike.
+ * @param {UmbElementDetailModel} element - the resolved Element.
+ * @returns {UmbBlockDataModel} the block data.
+ */
+function elementToBlockData(element) {
+    return {
+        key: element.unique,
+        contentTypeKey: element.documentType.unique,
+        values: element.values.map((v) => ({
+            alias: v.alias,
+            editorAlias: v.editorAlias,
+            culture: v.culture,
+            segment: v.segment,
+            value: v.value,
+        })),
+    };
+}
+/**
+ * Maps a resolved Element's variant to the external content variant shape.
+ * @param {UmbElementDetailModel['variants'][number]} variant - the Element's variant.
+ * @returns {UmbBlockManagerExternalContentVariantModel} the external content variant.
+ */
+function elementVariantToExternalContentVariant(variant) {
+    return {
+        culture: variant.culture ?? null,
+        state: variant.state ?? null,
+        name: variant.name ?? null,
+    };
+}
 export class UmbBlockManagerContext extends UmbContextBase {
     get contentTypesLoaded() {
         return Promise.all(this.#contentTypeRequests);
@@ -35,6 +78,16 @@ export class UmbBlockManagerContext extends UmbContextBase {
     #blockTypes;
     #contents;
     #contentKeys;
+    #externalContentValues;
+    #externalContentVariants;
+    #externalContentFailures;
+    #unavailableExternalContentKeys;
+    #isProbingExternalContentFailures;
+    #elementRepository;
+    #elementPublishingRepository;
+    #elementValidationRepository;
+    #localize;
+    #externalContentManager;
     #settings;
     #settingsKeys;
     #exposes;
@@ -61,7 +114,8 @@ export class UmbBlockManagerContext extends UmbContextBase {
      * @param {Array<BlockLayoutType>} layouts - All layouts.
      */
     setLayouts(layouts) {
-        this._layouts.setValue(layouts);
+        // Backwards compatibility: ensure all layouts have a key (persisted data may not have one)
+        this._layouts.setValue(layouts.map((layout) => (layout.key ? layout : { ...layout, key: layout.contentKey })));
     }
     /**
      * Get all layouts.
@@ -129,23 +183,61 @@ export class UmbBlockManagerContext extends UmbContextBase {
         this.editorConfiguration = this._editorConfiguration.asObservable();
         this._liveEditingMode = new UmbBooleanState(undefined);
         this.liveEditingMode = this._liveEditingMode.asObservable();
-        this._layouts = new UmbArrayState([], (x) => x.contentKey);
+        this._layouts = new UmbArrayState([], (x) => x.key);
         this.layouts = this._layouts.asObservable();
         this.#contents = new UmbArrayState(undefined, (x) => x.key);
         // TODO: Remove ?? [] fallback in v.19 (or v.20)
         this.contents = this.#contents.asObservablePart((x) => x ?? []);
         this.#contentKeys = this.#contents.asObservablePart((x) => (x ? x.map((y) => y.key) : undefined));
+        this.#externalContentValues = new UmbArrayState([], (x) => x.key);
+        /**
+         * Combined observable of local block content and resolved external (library element) content.
+         * Use this alongside `contents` when you also need to react to library elements becoming available.
+         * The two arrays are concatenated without de-duplication — a key present in both (which should not
+         * normally happen) appears twice, with the local entry taking precedence in lookups like `getContentOf`.
+         */
+        this.allContents = mergeObservables([this.#contents.asObservable(), this.#externalContentValues.asObservable()], ([local, external]) => [...(local ?? []), ...(external ?? [])]);
+        this.#externalContentVariants = new UmbArrayState([], (x) => x.key);
+        this.#externalContentFailures = new UmbArrayState([], (x) => x.key);
+        this.#unavailableExternalContentKeys = new Array();
+        this.#isProbingExternalContentFailures = false;
+        this.#elementRepository = new UmbElementDetailRepository(this);
+        this.#elementPublishingRepository = new UmbElementPublishingRepository(this);
+        this.#elementValidationRepository = new UmbElementValidationRepository(this);
+        this.#localize = new UmbLocalizationController(this);
+        this.#externalContentManager = new UmbRepositoryDetailsManager(this, this.#elementRepository);
         this.#settings = new UmbArrayState(undefined, (x) => x.key);
         // TODO: Remove ?? [] fallback in v.19 (or v.20)
         this.settings = this.#settings.asObservablePart((x) => x ?? []);
         this.#settingsKeys = this.#settings.asObservablePart((x) => (x ? x.map((y) => y.key) : undefined));
         // TODO: This is a bad seperation of concerns, this should be self initializing, not defined from the outside. [NL]
         this.readOnlyState = new UmbReadOnlyVariantGuardManager(this);
-        this.#exposes = new UmbArrayState([], (x) => x.contentKey + '_' + x.culture + '_' + x.segment);
+        this.#exposes = new UmbArrayState([], (x) => x.contentKey + ':' + x.culture).sortBy(umbBlockExposeSortCompare);
         this.exposes = this.#exposes.asObservable();
         this.observe(this.blockTypes, (blockTypes) => {
             this.#ensureContentTypes(blockTypes);
         }, null);
+        // Keep the details manager's uniques in sync with any layout marked as external, so it resolves
+        // (and re-resolves on `UmbEntityUpdatedEvent`) the Elements those layouts reference, and drops any
+        // that are no longer referenced.
+        this.observe(this._layouts.asObservable(), (layouts) => {
+            this.#externalContentManager.setUniques([...new Set(this._collectExternalContentKeys(layouts))]);
+        }, null);
+        // Reflect the resolved Elements into the external content states whenever they change.
+        this.observe(this.#externalContentManager.entries, (entries) => {
+            this.#externalContentValues.setValue(entries.map(elementToBlockData));
+            this.#externalContentVariants.setValue(entries.map((entry) => ({
+                key: entry.unique,
+                variants: entry.variants.map(elementVariantToExternalContentVariant),
+            })));
+        }, null);
+        // The batched request only says that an element is missing, not why. Ask for each missing element on its own
+        // to tell a deleted element from one the current user may not access.
+        this.observe(this.#externalContentManager.statuses, (statuses) => {
+            this.#externalContentFailures.remove(statuses.filter((status) => status.state.type === 'success').map((status) => status.unique));
+            this.#unavailableExternalContentKeys = statuses.filter((status) => status.state.type === 'error').map((status) => status.unique);
+            this.#requestExternalContentFailures();
+        }, null);
         // Clean up validation messages for Block content/settings that are no longer part of this Block
         // Editor's data. Deliberately does not skip the host: we want the Validation Context of the
         // Property Editor hosting this Block Manager, which is provided on this very same element. [NL]
@@ -254,7 +346,78 @@ export class UmbBlockManagerContext extends UmbContextBase {
         return this._layouts.asObservablePart((source) => source.find((x) => x.contentKey === contentKey));
     }
     contentOf(key) {
-        return this.#contents.asObservablePart((source) => source?.find((x) => x.key === key));
+        return mergeObservables([
+            this.#contents.asObservablePart((source) => source?.find((x) => x.key === key)),
+            this.#externalContentValues.asObservablePart((source) => source.find((x) => x.key === key)),
+        ], ([localContent, externalContent]) => localContent ?? externalContent ?? undefined);
+    }
+    /**
+     * Collects the content keys of every layout entry marked as external content. Override to also reach
+     * layout entries that are nested inside other entries.
+     * @param {Array<BlockLayoutType>} layouts - the top-level layout entries.
+     * @returns {Array<string>} the content keys of the external content layouts, one per reference.
+     */
+    _collectExternalContentKeys(layouts) {
+        return layouts.filter((layout) => layout.isExternalContent && layout.contentKey).map((layout) => layout.contentKey);
+    }
+    /**
+     * Returns an observable that emits true when a layout entry for the given contentKey, at any nesting
+     * level reached by {@link _collectExternalContentKeys}, has `isExternalContent` set (i.e., the block
+     * references external content).
+     * @param key
+     */
+    isExternalContentOf(key) {
+        return this._layouts.asObservablePart((layouts) => this._collectExternalContentKeys(layouts).includes(key));
+    }
+    /**
+     * Returns an observable of the external content variant state.
+     * Emits the state string (e.g., 'Published', 'Draft') or null if not resolved yet.
+     * @param key
+     */
+    externalContentStateOf(key) {
+        return mergeObservables([this.#externalContentVariants.asObservablePart((source) => source.find((x) => x.key === key)), this.variantId], ([entry, variantId]) => findExternalContentVariant(entry?.variants, variantId)?.state ?? null);
+    }
+    /**
+     * Returns an observable of the external content's name (from the Element it references), matching the
+     * current variant. Emits null if the external content has not resolved yet, or is not external content.
+     * @param key
+     */
+    externalContentNameOf(key) {
+        return mergeObservables([this.#externalContentVariants.asObservablePart((source) => source.find((x) => x.key === key)), this.variantId], ([entry, variantId]) => findExternalContentVariant(entry?.variants, variantId)?.name ?? null);
+    }
+    /**
+     * Returns an observable of why the external content is unavailable.
+     * Emits `undefined` while the content is available or not yet resolved.
+     * @param key The content key of the external content.
+     */
+    externalContentFailureOf(key) {
+        return this.#externalContentFailures.asObservablePart((source) => source.find((x) => x.key === key)?.reason);
+    }
+    async #requestExternalContentFailures() {
+        // One request at a time, so that a server that is down is asked once, not once per referenced element.
+        if (this.#isProbingExternalContentFailures)
+            return;
+        this.#isProbingExternalContentFailures = true;
+        try {
+            let key = this.#nextUnexplainedExternalContentKey();
+            while (key) {
+                const { error } = await this.#elementRepository.requestByUnique(key);
+                const reason = getExternalContentFailureReason(error);
+                // A failure that says nothing about availability (the server being down, for example) is no reason to ask
+                // about the other elements as well. They are asked again the next time the statuses change.
+                if (!reason)
+                    return;
+                this.#externalContentFailures.appendOne({ key, reason });
+                key = this.#nextUnexplainedExternalContentKey();
+            }
+        }
+        finally {
+            this.#isProbingExternalContentFailures = false;
+        }
+    }
+    #nextUnexplainedExternalContentKey() {
+        const explained = this.#externalContentFailures.getValue();
+        return this.#unavailableExternalContentKeys.find((key) => !explained.some((x) => x.key === key));
     }
     settingsOf(key) {
         return this.#settings.asObservablePart((source) => source?.find((x) => x.key === key));
@@ -275,7 +438,7 @@ export class UmbBlockManagerContext extends UmbContextBase {
             const varyByCulture = contentStructure.getVariesByCulture();
             const varyBySegment = contentStructure.getVariesBySegment();
             const blockVariantId = variantId.toVariant(varyByCulture, varyBySegment);
-            return exposes.find((x) => blockVariantId.compare(x));
+            return exposes.find((x) => blockVariantId.culture === x.culture);
         });
     }
     hasExposeOf(contentKey, variantId) {
@@ -296,17 +459,17 @@ export class UmbBlockManagerContext extends UmbContextBase {
             throw new Error(`Cannot lookup expose of block, missing content structure for ${contentTypeKey}`);
         }
         const varyByCulture = contentStructure.getVariesByCulture();
-        const varyBySegment = contentStructure.getVariesBySegment();
-        const blockVariantId = variantId.toVariant(varyByCulture, varyBySegment);
+        const blockVariantId = variantId.toVariant(varyByCulture);
         return this.#exposes.asObservablePart((exposes) => {
-            return exposes.some((x) => x.contentKey === contentKey && blockVariantId.compare(x));
+            return exposes.some((x) => x.contentKey === contentKey && blockVariantId.culture === x.culture);
         });
     }
     getBlockTypeOf(contentTypeKey) {
         return this.#blockTypes.value.find((x) => x.contentElementTypeKey === contentTypeKey);
     }
     getContentOf(contentKey) {
-        return this.#contents.value?.find((x) => x.key === contentKey);
+        return (this.#contents.value?.find((x) => x.key === contentKey) ??
+            this.#externalContentValues.value.find((x) => x.key === contentKey));
     }
     getSettingsOf(settingsKey) {
         return this.#settings.value?.find((x) => x.key === settingsKey);
@@ -345,9 +508,198 @@ export class UmbBlockManagerContext extends UmbContextBase {
         const variantId = this.getVariantId();
         if (!variantId)
             return;
-        this.#exposes.filter((x) => !(x.contentKey === contentKey && variantId.compare(x)));
+        this.#exposes.filter((x) => !(x.contentKey === contentKey && variantId.culture === x.culture));
     }
     /**
+     * Insert a block whose content is an external content reference.
+     * Only creates a layout entry — no contentData entry is added.
+     * The layout observer handles fetching the element data.
+     * The layout is placed through `setOneLayout`, so implementations can position it from the origin data.
+     * @param {string} elementKey - The key of the external element to reference.
+     * @param {BlockOriginDataType} [originData] - Where the block was requested from, used by implementations to position it.
+     */
+    insertExternalContent(elementKey, originData) {
+        const layout = { key: UmbId.new(), contentKey: elementKey, isExternalContent: true };
+        this.setOneLayout(layout, originData);
+    }
+    /**
+     * Request to transfer a local block's content to external content (Element Library).
+     * The Element is created from all cultures the block holds data in, and published in the cultures the block is exposed in.
+     * Nothing is transferred when the user lacks access to a language the block holds data in.
+     * @param {string} key the block layout key.
+     * @param name
+     * @returns {Promise<UmbBlockTransferToExternalContentResult | undefined>} The outcome, or `undefined` when nothing was transferred.
+     */
+    async requestTransferToExternalContent(key, name) {
+        const layout = this._layouts.getValue().find((x) => x.key === key);
+        if (!layout)
+            return;
+        const contentKey = layout.contentKey;
+        const content = this.getContentOf(contentKey);
+        if (!content)
+            return;
+        await this.contentTypesLoaded;
+        const variesByCulture = this.getStructure(content.contentTypeKey)?.getVariesByCulture() ?? false;
+        const valueCultures = await this.#getValueCultures(content.values);
+        const access = await this.#getTransferLanguageAccess();
+        if (!access)
+            return;
+        const blocked = umbGetBlockedTransferVariants({ valueCultures, variesByCulture, access });
+        if (blocked.cultures.length > 0 || blocked.invariant) {
+            await this.#showTransferNotPermitted(blocked);
+            return;
+        }
+        const modalManager = await this.getContext(UMB_MODAL_MANAGER_CONTEXT).catch(() => undefined);
+        if (!modalManager)
+            return;
+        const result = await modalManager
+            .open(this, UMB_BLOCK_TRANSFER_TO_ELEMENT_LIBRARY_MODAL, {
+            data: { name, contentTypeKey: content.contentTypeKey },
+        })
+            .onSubmit()
+            .catch(() => undefined);
+        if (!result)
+            return;
+        const { cultures, culturesToPublish } = umbResolveBlockTransferCultures({
+            valueCultures,
+            exposedCultures: this.getExposes()
+                .filter((x) => x.contentKey === contentKey)
+                .map((x) => x.culture),
+            variesByCulture,
+            fallbackCulture: this.getVariantId()?.culture,
+            access,
+        });
+        const { data: scaffold } = await this.#elementRepository.createScaffold({
+            documentType: { unique: content.contentTypeKey, collection: null },
+            values: content.values,
+            variants: cultures.map((culture) => ({
+                culture,
+                state: null,
+                name: result.name,
+                publishDate: null,
+                createDate: null,
+                updateDate: null,
+            })),
+        });
+        if (!scaffold)
+            return;
+        const { data: created } = await this.#elementRepository.create(scaffold, result.parentUnique);
+        if (!created)
+            return;
+        // Publish before swapping the layout, as the layout change makes the external content manager fetch the Element.
+        const publishResult = await this.#publishTransferredElement(created, culturesToPublish);
+        this.#contents.removeOne(contentKey);
+        this.removeExposesOf(contentKey);
+        this._layouts.updateOne(key, {
+            contentKey: created.unique,
+            isExternalContent: true,
+        });
+        return { unique: created.unique, ...publishResult };
+    }
+    async #getValueCultures(values) {
+        const cultures = await new UmbPropertyValueFlatMapperController(this).flatMapMany(values, (property) => 
+        // Be aware that a value of `false` or `""` or `[]` is not captured here:
+        property.value ? property.culture : undefined);
+        return cultures.filter((culture) => culture !== undefined);
+    }
+    async #getTransferLanguageAccess() {
+        const context = await this.getContext(UMB_CURRENT_USER_CONTEXT).catch(() => undefined);
+        if (!context)
+            return;
+        const user = await this.observe(context.currentUser).asPromise();
+        return {
+            hasAccessToAllLanguages: user.hasAccessToAllLanguages,
+            languages: user.languages,
+            hasAccessToInvariantForVariant: user.hasAccessToInvariantForVariant !== false,
+        };
+    }
+    async #showTransferNotPermitted(blocked) {
+        const appLanguageContext = await this.getContext(UMB_APP_LANGUAGE_CONTEXT).catch(() => undefined);
+        // Resolves once the languages have loaded.
+        await appLanguageContext?.getMandatoryLanguages();
+        const languages = appLanguageContext ? await this.observe(appLanguageContext.languages).asPromise() : [];
+        const languageNames = blocked.cultures.map((culture) => languages.find((language) => language.unique === culture)?.name ?? culture);
+        const content = [];
+        if (languageNames.length > 0) {
+            content.push(this.#localize.term('blockEditor_transferToElementLibraryLanguagesNotPermitted', escapeHTML(languageNames.join(', '))));
+        }
+        if (blocked.invariant) {
+            content.push(this.#localize.term('blockEditor_transferToElementLibrarySharedNotPermitted'));
+        }
+        await umbInfoModal(this, {
+            headline: '#blockEditor_transferToElementLibraryNotPermitted',
+            content: content.join(' '),
+        }).catch(() => undefined);
+    }
+    async #publishTransferredElement(element, culturesToPublish) {
+        if (culturesToPublish.length === 0)
+            return { status: 'draft' };
+        const variantIds = culturesToPublish.map((culture) => new UmbVariantId(culture));
+        // Validated without notifications, so a failure is reported once, by the caller.
+        const { error: validationError } = await this.#elementValidationRepository.validateSave(element, variantIds);
+        if (validationError) {
+            if (UmbApiError.isUmbApiError(validationError) && isPublishValidationError(validationError)) {
+                return { status: 'validation-failed' };
+            }
+            return { status: 'publish-failed' };
+        }
+        const { error } = await this.#elementPublishingRepository.publish(element.unique, variantIds.map((variantId) => ({ variantId })));
+        if (!error)
+            return { status: 'published' };
+        if (UmbApiError.isUmbApiError(error) && isPublishValidationError(error))
+            return { status: 'validation-failed' };
+        return { status: 'publish-failed', notified: apiErrorWasNotified(error) };
+    }
+    /**
+     * Request to disconnect a block from external content (Element Library).
+     * @param {string} key the block layout key.
+     */
+    async requestDisconnectFromExternalContent(key) {
+        const layout = this._layouts.getValue().find((x) => x.key === key);
+        if (!layout)
+            return;
+        const elementKey = layout.contentKey;
+        try {
+            await umbConfirmModal(this, {
+                headline: '#blockEditor_disconnectFromElementLibrary',
+                content: '#blockEditor_disconnectFromElementLibraryConfirm',
+                confirmLabel: '#blockEditor_disconnectFromElementLibrary',
+                color: 'warning',
+            });
+        }
+        catch {
+            return; // user cancelled
+        }
+        const { data: element } = await this.#elementRepository.requestByUnique(elementKey);
+        if (!element)
+            return;
+        const contentTypeKey = element.documentType.unique;
+        const newContent = {
+            key: UmbId.new(),
+            contentTypeKey,
+            values: element.values.map((v) => ({
+                alias: v.alias,
+                editorAlias: v.editorAlias,
+                culture: v.culture,
+                segment: v.segment,
+                value: v.value,
+            })),
+        };
+        this.#contents.appendOne(newContent);
+        this._layouts.updateOne(key, {
+            contentKey: newContent.key,
+            isExternalContent: undefined,
+        });
+        // Only set expose if the content type structure is loaded (it may not be for external content
+        // whose type was not in the block type list)
+        if (this.getStructure(contentTypeKey)) {
+            this.#setInitialBlockExpose(newContent);
+        }
+    }
+    /**
+     * @param key
+     * @param propertyAlias
+     * @param value
      * @deprecated this is not working, use the Property Dataset instead.
      */
     // TODO: Deprecate and remove this.
@@ -355,6 +707,9 @@ export class UmbBlockManagerContext extends UmbContextBase {
         this.#contents.updateOne(key, { [propertyAlias]: value });
     }
     /**
+     * @param key
+     * @param propertyAlias
+     * @param value
      * @deprecated this is not working, use the Property Dataset instead.
      */
     // TODO: Deprecate and remove this.
@@ -362,6 +717,8 @@ export class UmbBlockManagerContext extends UmbContextBase {
         this.#settings.updateOne(key, { [propertyAlias]: value });
     }
     /**
+     * @param key
+     * @param propertyAlias
      * @deprecated this is not working, use the Property Dataset instead.
      */
     // TODO: Deprecate and remove this.
@@ -369,6 +726,8 @@ export class UmbBlockManagerContext extends UmbContextBase {
         this.#contents.asObservablePart((source) => source?.find((x) => x.key === key)?.values?.find((values) => values.alias === propertyAlias)?.value);
     }
     /**
+     * @param key
+     * @param propertyAlias
      * @deprecated this is not working, use the Property Dataset instead.
      */
     // TODO: Deprecate and remove this.
@@ -385,8 +744,8 @@ export class UmbBlockManagerContext extends UmbContextBase {
         }
         // TODO: Handle presets here [NL]
         return {
-            key: UmbId.new(),
             contentTypeKey: blockType.settingsElementTypeKey,
+            key: UmbId.new(),
             values: [],
         };
     }
@@ -461,9 +820,11 @@ export class UmbBlockManagerContext extends UmbContextBase {
         if (!blockType) {
             throw new Error(`Cannot create block, missing block type for ${contentElementTypeKey}`);
         }
+        const contentKey = UmbId.new();
         // Create layout entry:
         const layout = {
-            contentKey: UmbId.new(),
+            key: contentKey,
+            contentKey,
             ...partialLayoutEntry,
         };
         const content = await this._createBlockElementData(layout.contentKey, contentElementTypeKey);

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

@@ -7,6 +7,7 @@ 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-entity-reference/index.js';
 export * from './property-value-resolver/index.js';
 export * from './validation/index.js';
 export * from './workspace/index.js';

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

@@ -7,6 +7,7 @@ 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-entity-reference/index.js';
 export * from './property-value-resolver/index.js';
 export * from './validation/index.js';
 export * from './workspace/index.js';

package/dist-cms/packages/block/block/modals/block-catalogue/block-catalogue-modal.element.d.ts

@@ -3,7 +3,8 @@ import { UmbModalBaseElement } from '../../../../core/modal/index.js';
 export declare class UmbBlockCatalogueModalElement extends UmbModalBaseElement<UmbBlockCatalogueModalData, UmbBlockCatalogueModalValue> {
     #private;
     private _groupedBlocks;
-    private _openClipboard?;
+    private _activeView;
+    private _searchQuery;
     private _workspacePath?;
     private _filtered;
     private _manager?;