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

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

@@ -1,5 +1,7 @@
 import type { UmbConditionConfigBase } from '../../../../libs/extension-api/index.js';
 export type BlockWorkspaceHasSettingsConditionConfig = UmbConditionConfigBase<'Umb.Condition.BlockWorkspaceHasSettings'>;
+export interface BlockWorkspaceHasContentConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockWorkspaceHasContent'> {
+}
 export interface BlockEntryShowContentEditConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockEntryShowContentEdit'> {
     match?: boolean;
 }
@@ -9,15 +11,25 @@ export interface BlockEntryIsExposedConditionConfig extends UmbConditionConfigBa
 export interface BlockWorkspaceIsReadOnlyConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockWorkspaceIsReadOnly'> {
     match?: boolean;
 }
-export type BlockEntryHasSettingsConditionConfig = UmbConditionConfigBase<'Umb.Condition.BlockEntryHasSettings'>;
+export interface BlockEntryHasSettingsConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockEntryHasSettings'> {
+}
+export interface BlockEntryHasExternalContentConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockEntryHasExternalContent'> {
+    match?: boolean;
+}
 export interface BlockEntryIsReadOnlyConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockEntryIsReadOnly'> {
     match?: boolean;
 }
+export interface BlockEntryIsAllowedInLibraryConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockEntryIsAllowedInLibrary'> {
+    match?: boolean;
+}
+export interface BlockEntryIsUnsupportedConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockEntryIsUnsupported'> {
+    match?: boolean;
+}
 export interface UmbBlockEntryIsExposedConditionConfig extends UmbConditionConfigBase<'Umb.Condition.BlockEntryIsExposed'> {
     match?: boolean;
 }
 declare global {
     interface UmbExtensionConditionConfigMap {
-        umbBlock: BlockEntryShowContentEditConditionConfig | BlockWorkspaceHasSettingsConditionConfig | BlockEntryIsExposedConditionConfig | BlockWorkspaceIsReadOnlyConditionConfig | BlockEntryIsReadOnlyConditionConfig | BlockEntryHasSettingsConditionConfig | UmbBlockEntryIsExposedConditionConfig;
+        umbBlock: BlockEntryShowContentEditConditionConfig | BlockWorkspaceHasSettingsConditionConfig | BlockWorkspaceHasContentConditionConfig | BlockEntryIsExposedConditionConfig | BlockEntryHasExternalContentConditionConfig | BlockWorkspaceIsReadOnlyConditionConfig | BlockEntryIsReadOnlyConditionConfig | BlockEntryHasSettingsConditionConfig | BlockEntryIsAllowedInLibraryConditionConfig | BlockEntryIsUnsupportedConditionConfig | UmbBlockEntryIsExposedConditionConfig;
     }
 }

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

@@ -1,13 +1,15 @@
 import type { UmbBlockWorkspaceOriginData } from '../workspace/block-workspace.modal-token.js';
 import type { UmbBlockDataModel, UmbBlockLayoutBaseModel, UmbBlockValueType } from '../types.js';
 import type { UmbBlockDataObjectModel, UmbBlockManagerContext } from './block-manager.context.js';
-import { type Observable, UmbArrayState, UmbBasicState, UmbStringState } from '../../../../libs/observable-api/index.js';
+import { UmbArrayState, UmbBasicState, UmbStringState } from '../../../../libs/observable-api/index.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
+import type { Observable } from '../../../../libs/observable-api/index.js';
 import type { UmbContextToken } from '../../../../libs/context-api/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 import type { UmbModalRouteBuilder } from '../../../core/router/index.js';
 import type { UmbBlockTypeBaseModel } from '../../block-type/index.js';
 export declare abstract class UmbBlockEntriesContext<BlockManagerContextTokenType extends UmbContextToken<BlockManagerContextType, BlockManagerContextType>, BlockManagerContextType extends UmbBlockManagerContext<BlockType, BlockLayoutType, BlockOriginData>, BlockType extends UmbBlockTypeBaseModel, BlockLayoutType extends UmbBlockLayoutBaseModel, BlockOriginData extends UmbBlockWorkspaceOriginData> extends UmbContextBase {
+    #private;
     protected _manager?: BlockManagerContextType;
     protected _retrieveManager: Promise<BlockManagerContextType | undefined>;
     protected _catalogueRouteBuilderState: UmbBasicState<UmbModalRouteBuilder | undefined>;
@@ -19,6 +21,8 @@ export declare abstract class UmbBlockEntriesContext<BlockManagerContextTokenTyp
     protected _layoutEntries: UmbArrayState<BlockLayoutType, unknown, BlockLayoutType[]>;
     readonly layoutEntries: Observable<BlockLayoutType[]>;
     readonly layoutEntriesLength: Observable<number>;
+    readonly libraryAllowedElementTypeKeys: Observable<string[]>;
+    readonly hasLibraryElements: Observable<boolean>;
     getLength(): number;
     /**
      * Returns the current layout entries.
@@ -30,14 +34,37 @@ export declare abstract class UmbBlockEntriesContext<BlockManagerContextTokenTyp
     setDataPath(path: string): void;
     protected abstract _gotBlockManager(): void;
     layoutOf(contentKey: string): Observable<BlockLayoutType | undefined>;
+    byKey(key: string): Observable<BlockLayoutType | undefined>;
     getLayoutOf(contentKey: string): BlockLayoutType | undefined;
+    getByKey(key: string): BlockLayoutType | undefined;
     setLayouts(layouts: Array<BlockLayoutType>): void;
     setOneLayout(layoutData: BlockLayoutType): UmbArrayState<BlockLayoutType, unknown, BlockLayoutType[]>;
     abstract getPathForCreateBlock(index: number): string | undefined;
     abstract getPathForClipboard(index: number): string | undefined;
-    abstract create(contentElementTypeKey: string, layoutEntry?: Omit<BlockLayoutType, 'contentKey'>, originData?: BlockOriginData): Promise<UmbBlockDataObjectModel<BlockLayoutType> | undefined>;
+    /**
+     * Returns the element type uniques allowed at the library root that overlap
+     * with the given block types — used to filter the library picker in the
+     * block catalogue modal.
+     * @param {Array<BlockType>} blockTypes The block types to filter by.
+     * @returns {Promise<Array<string>>} The allowed element type uniques.
+     */
+    protected _getLibraryAllowedElementTypeKeys(blockTypes: Array<BlockType>): Promise<Array<string>>;
+    /**
+     * Keeps `hasLibraryElements` in sync with whether any of the given block types
+     * is also allowed at the library root — the same rule the block catalogue modal
+     * uses to offer the Library tab.
+     * @param {Observable<Array<BlockType>>} blockTypes The block types the editor offers.
+     */
+    protected _observeLibraryBlockTypes(blockTypes: Observable<Array<BlockType>>): void;
+    /**
+     * Inserts an existing Library element as an external-content reference.
+     * @param {string} elementKey The key of the element to reference.
+     * @param {UmbBlockWorkspaceOriginData} [originData] Where the block was requested from, used to position it.
+     */
+    protected _insertExternalContent(elementKey: string, originData?: UmbBlockWorkspaceOriginData): void;
+    abstract create(contentElementTypeKey: string, layoutEntry?: Omit<BlockLayoutType, 'contentKey' | 'key'>, originData?: BlockOriginData): Promise<UmbBlockDataObjectModel<BlockLayoutType> | undefined>;
     abstract insert(layoutEntry: BlockLayoutType, content: UmbBlockDataModel, settings: UmbBlockDataModel | undefined, originData: BlockOriginData): Promise<boolean>;
-    delete(contentKey: string): Promise<void>;
+    delete(key: string): Promise<void>;
     protected _insertFromPropertyValues(values: Array<UmbBlockValueType>, originData: BlockOriginData): Promise<void>;
     protected abstract _insertFromPropertyValue(values: UmbBlockValueType, originData: BlockOriginData): Promise<BlockOriginData>;
     protected _insertBlockFromPropertyValue(layoutEntry: BlockLayoutType, value: UmbBlockValueType, originData: BlockOriginData): Promise<void>;

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

@@ -1,7 +1,11 @@
 import { UMB_BLOCK_ENTRIES_CONTEXT } from './block-entries.context-token.js';
-import { UmbArrayState, UmbBasicState, UmbStringState } from '../../../../libs/observable-api/index.js';
+import { UmbArrayState, UmbBasicState, UmbBooleanState, UmbStringState, observeMultiple, } from '../../../../libs/observable-api/index.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
+import { UmbElementTypeStructureRepository } from '../../../elements/index.js';
 export class UmbBlockEntriesContext extends UmbContextBase {
+    #libraryAllowedElementTypeKeys;
+    #libraryAllowedElementTypeKeysPromise;
+    #hasLibraryElements;
     getLength() {
         return this._layoutEntries.getValue().length;
     }
@@ -18,14 +22,26 @@ export class UmbBlockEntriesContext extends UmbContextBase {
         this.catalogueRouteBuilder = this._catalogueRouteBuilderState.asObservable();
         this._workspacePath = new UmbStringState(undefined);
         this.workspacePath = this._workspacePath.asObservable();
-        this._layoutEntries = new UmbArrayState([], (x) => x.contentKey);
+        this._layoutEntries = new UmbArrayState([], (x) => x.key);
         this.layoutEntries = this._layoutEntries.asObservable();
         this.layoutEntriesLength = this._layoutEntries.asObservablePart((x) => x.length);
+        this.#libraryAllowedElementTypeKeys = new UmbArrayState([], (x) => x);
+        this.libraryAllowedElementTypeKeys = this.#libraryAllowedElementTypeKeys.asObservable();
+        this.#hasLibraryElements = new UmbBooleanState(false);
+        this.hasLibraryElements = this.#hasLibraryElements.asObservable();
         // TODO: Observe Blocks of the layout entries of this component.
         this._retrieveManager = this.consumeContext(blockManagerContextToken, (blockGridManager) => {
             this._manager = blockGridManager;
             this._gotBlockManager();
         }).asPromise({ preventTimeout: true });
+        this.#libraryAllowedElementTypeKeysPromise = this.#loadLibraryAllowedElementTypeKeys();
+    }
+    async #loadLibraryAllowedElementTypeKeys() {
+        const repo = new UmbElementTypeStructureRepository(this);
+        const { data: allowedTypes } = await repo.requestAllowedChildrenOf(null, null);
+        const keys = allowedTypes?.items.filter((t) => t.unique).map((t) => t.unique) ?? [];
+        this.#libraryAllowedElementTypeKeys.setValue(keys);
+        return keys;
     }
     async getManager() {
         await this._retrieveManager;
@@ -38,27 +54,68 @@ export class UmbBlockEntriesContext extends UmbContextBase {
     layoutOf(contentKey) {
         return this._layoutEntries.asObservablePart((source) => source.find((x) => x.contentKey === contentKey));
     }
+    byKey(key) {
+        return this._layoutEntries.asObservablePart((source) => source.find((x) => x.key === key));
+    }
     getLayoutOf(contentKey) {
         return this._layoutEntries.getValue().find((x) => x.contentKey === contentKey);
     }
+    getByKey(key) {
+        return this._layoutEntries.getValue().find((x) => x.key === key);
+    }
     setLayouts(layouts) {
         return this._layoutEntries.setValue(layouts);
     }
     setOneLayout(layoutData) {
         return this._layoutEntries.appendOne(layoutData);
     }
-    async delete(contentKey) {
+    /**
+     * Returns the element type uniques allowed at the library root that overlap
+     * with the given block types — used to filter the library picker in the
+     * block catalogue modal.
+     * @param {Array<BlockType>} blockTypes The block types to filter by.
+     * @returns {Promise<Array<string>>} The allowed element type uniques.
+     */
+    async _getLibraryAllowedElementTypeKeys(blockTypes) {
+        const allowedKeys = await this.#libraryAllowedElementTypeKeysPromise;
+        const blockTypeKeys = new Set(blockTypes.map((bt) => bt.contentElementTypeKey));
+        return allowedKeys.filter((key) => blockTypeKeys.has(key));
+    }
+    /**
+     * Keeps `hasLibraryElements` in sync with whether any of the given block types
+     * is also allowed at the library root — the same rule the block catalogue modal
+     * uses to offer the Library tab.
+     * @param {Observable<Array<BlockType>>} blockTypes The block types the editor offers.
+     */
+    _observeLibraryBlockTypes(blockTypes) {
+        this.observe(observeMultiple([blockTypes, this.libraryAllowedElementTypeKeys]), ([types, libraryKeys]) => {
+            this.#hasLibraryElements.setValue(types.some((x) => libraryKeys.includes(x.contentElementTypeKey)));
+        }, 'observeHasLibraryElements');
+    }
+    /**
+     * Inserts an existing Library element as an external-content reference.
+     * @param {string} elementKey The key of the element to reference.
+     * @param {UmbBlockWorkspaceOriginData} [originData] Where the block was requested from, used to position it.
+     */
+    _insertExternalContent(elementKey, originData) {
+        this._manager?.insertExternalContent(elementKey, originData);
+    }
+    async delete(key) {
         await this._retrieveManager;
-        const layout = this._layoutEntries.value.find((x) => x.contentKey === contentKey);
+        const layout = this._layoutEntries.value.find((x) => x.key === key);
         if (!layout) {
-            throw new Error(`Cannot delete block, missing layout for ${contentKey}`);
+            throw new Error(`Cannot delete block, missing layout for ${key}`);
         }
-        this._layoutEntries.removeOne(contentKey);
-        this._manager.removeOneContent(contentKey);
-        if (layout.settingsKey) {
-            this._manager.removeOneSettings(layout.settingsKey);
+        this._layoutEntries.removeOne(key);
+        // Only remove content/settings/exposes if no other layout references the same contentKey
+        const hasOtherReference = this._layoutEntries.value.some((x) => x.key !== key && x.contentKey === layout.contentKey);
+        if (!hasOtherReference) {
+            this._manager.removeOneContent(layout.contentKey);
+            if (layout.settingsKey) {
+                this._manager.removeOneSettings(layout.settingsKey);
+            }
+            this._manager.removeExposesOf(layout.contentKey);
         }
-        this._manager.removeExposesOf(contentKey);
     }
     // insert/paste from property value methods:
     async _insertFromPropertyValues(values, originData) {
@@ -67,6 +124,11 @@ export class UmbBlockEntriesContext extends UmbContextBase {
         }));
     }
     async _insertBlockFromPropertyValue(layoutEntry, value, originData) {
+        // External-content references have no inline contentData — insert as a reference instead.
+        if (layoutEntry.isExternalContent) {
+            await this._manager?.insertExternalContent(layoutEntry.contentKey, originData);
+            return;
+        }
         const content = value.contentData.find((x) => x.key === layoutEntry.contentKey);
         if (!content) {
             throw new Error('No content found for layout entry');

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

@@ -1,5 +1,5 @@
 import type { UmbBlockManagerContext, UmbBlockWorkspaceOriginData } from '../index.js';
-import type { UmbBlockLayoutBaseModel, UmbBlockDataModel, UmbBlockDataType, UmbBlockExposeModel, UmbBlockDataValueModel } from '../types.js';
+import type { UmbBlockLayoutBaseModel, UmbBlockDataModel, UmbBlockDataType, UmbBlockExposeModel, UmbBlockDataValueModel, UmbBlockExternalContentFailureReason } from '../types.js';
 import type { UmbBlockEntriesContext } from './block-entries.context.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbObjectState } from '../../../../libs/observable-api/index.js';
@@ -17,8 +17,28 @@ export declare abstract class UmbBlockEntryContext<BlockManagerContextTokenType
     protected _entries?: BlockEntriesContextType;
     readonly unsupported: Observable<boolean | undefined>;
     protected readonly localize: UmbLocalizationController<UmbKnownLocalizationSet>;
+    readonly isExternalContent: Observable<boolean>;
+    readonly isAllowedInLibrary: Observable<boolean | undefined>;
+    readonly externalContentVariantState: Observable<string | undefined>;
+    /**
+     * Observable of the name of the Element this block references, matching the current variant.
+     * Undefined for local (non-external) blocks, or before the Element has resolved.
+     */
+    readonly externalContentName: Observable<string | undefined>;
+    /**
+     * Why the external content of this Block is unavailable. `undefined` while it is available or not yet resolved.
+     */
+    readonly externalContentFailure: Observable<UmbBlockExternalContentFailureReason | undefined>;
     protected readonly _variantId: Observable<UmbVariantId | undefined>;
+    /**
+     * Whether the local expose entry exists. Prefer {@link isExposed} to determine rendered publish state.
+     */
     readonly hasExpose: Observable<boolean | undefined>;
+    /**
+     * Whether the block is currently published/exposed. For a block backed by external (library element)
+     * content, this reflects that content's own variant state rather than the local expose entry.
+     */
+    readonly isExposed: Observable<boolean | undefined>;
     readonly actionsVisibility: Observable<boolean>;
     hideActions(): void;
     showActions(): void;
@@ -72,16 +92,6 @@ export declare abstract class UmbBlockEntryContext<BlockManagerContextTokenType
      * @param {string} text the resolved text.
      */
     setName(text: string): void;
-    /**
-     * Whether this context should run its own hidden `UmbUfmVirtualRenderController` as the
-     * source of `getName()`. Subclasses whose entry element owns a canonical `<umb-ufm-render>`
-     * (and pushes text via {@link setName}) should override this to return `false`.
-     * @deprecated Scheduled for removal in Umbraco 19. Subclasses must own their own
-     * `<umb-ufm-render>` and push resolved text via {@link setName} — the hidden virtual
-     * renderer fallback will be removed entirely.
-     * @returns {boolean} `true` to create the legacy hidden renderer; `false` to skip it.
-     */
-    protected _needsLegacyLabelRenderer(): boolean;
     readonly workspacePath: Observable<string | undefined>;
     readonly workspaceEditContentPath: Observable<string>;
     readonly workspaceEditSettingsPath: Observable<string>;
@@ -101,10 +111,6 @@ export declare abstract class UmbBlockEntryContext<BlockManagerContextTokenType
     getContent(): UmbBlockDataModel | undefined;
     protected readonly _settingsValueArray: Observable<UmbBlockDataValueModel<unknown>[] | undefined>;
     private readonly _settingsDataContentTypeKey;
-    /**
-     * @deprecated Use {@link UmbBlockEntryContext#_settingsDataContentTypeKey} instead. This will be removed in Umbraco 18.
-     */
-    private readonly settingsDataContentTypeKey;
     settingsValues(): Promise<Observable<UmbBlockDataType | undefined>>;
     /**
      * Get the settings of the block.
@@ -114,11 +120,18 @@ export declare abstract class UmbBlockEntryContext<BlockManagerContextTokenType
     abstract readonly showContentEdit: Observable<boolean>;
     constructor(host: UmbControllerHost, blockManagerContextToken: BlockManagerContextTokenType, blockEntriesContextToken: BlockEntriesContextTokenType);
     getContentKey(): string | undefined;
+    /**
+     * Set the key of this entry — the unique identity of the block layout item.
+     * @param {string} key the block key.
+     */
+    setKey(key: string): void;
+    getKey(): string | undefined;
     /**
      * Set the contentKey of this entry.
      * @function setContentKey
      * @param {string} contentKey the entry content key.
      * @returns {void}
+     * @deprecated Use `setKey` instead. Will be removed in Umbraco 20.
      */
     setContentKey(contentKey: string): void;
     /**
@@ -133,6 +146,8 @@ export declare abstract class UmbBlockEntryContext<BlockManagerContextTokenType
     edit(): void;
     editSettings(): void;
     requestDelete(): Promise<void>;
+    requestTransferToExternalContent(): Promise<void>;
+    requestDisconnectFromExternalContent(): Promise<void>;
     delete(): void;
     expose(): void;
     /**