@umbraco-cms/backoffice 17.4.0-rc3 → 18.0.0-beta2

package/dist-cms/libs/class-api/class.interface.d.ts

@@ -25,17 +25,18 @@ export interface UmbClassInterface extends UmbControllerHost {
      */
     provideContext<R extends UmbContextMinimal = UmbContextMinimal>(alias: string | UmbContextToken<R>, instance: R): UmbContextProviderController<R>;
     /**
-     * @description Setup a subscription for a context. The callback is called when the context is resolved.
+     * @description Subscribe to a context. The callback fires when the context resolves, again if the context is replaced, and can also be invoked with `undefined` if the context is unprovided or the host disconnects. Use this whenever a controller or element needs the context at setup time — both for ongoing observation and for reading values immediately on resolve. This is the default choice; prefer it over `getContext` unless the context is only needed inside a later user action.
      * @param {string} alias
-     * @param {ObserverCallback} callback Callback method called when context is resolved.
+     * @param {UmbContextCallback} callback Callback method called with the resolved context instance or `undefined`.
      * @returns {UmbContextConsumerController} Reference to the created Context Consumer Controller instance
      * @memberof UmbClassInterface
      */
     consumeContext<BaseType extends UmbContextMinimal = UmbContextMinimal, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>): UmbContextConsumerController<BaseType, ResultType>;
     /**
-     * @description Retrieve a context. Notice this is a one time retrieving of a context, meaning if you expect this to be up to date with reality you should instead use the consumeContext method.
+     * @description Retrieve a context once as a Promise. Use this only when the context is first needed inside a user action or event handler that runs later (for example a button click, a property action, or an entity action `execute()`). For setup-time access — including a single immediate read — use `consumeContext` instead so the controller lifecycle handles resolution and cleanup. The returned Promise may reject if the context is not found before the default timeout; callers should handle rejection and/or pass `preventTimeout` in the options when waiting longer is expected.
      * @param {string} alias
-     * @returns {Promise<unknown>} A Promise with the reference to the Context Api Instance
+     * @param {UmbClassGetContextOptions} [options] Options for resolving the context once, including timeout-related behavior such as `preventTimeout`.
+     * @returns {Promise<ResultType | undefined>} A Promise resolving to the Context API instance when available, or `undefined` when applicable.
      * @memberof UmbClassInterface
      */
     getContext<BaseType extends UmbContextMinimal = UmbContextMinimal, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, options?: UmbClassGetContextOptions): Promise<ResultType | undefined>;

package/dist-cms/libs/controller-api/controller-host.mixin.d.ts

@@ -1,6 +1,6 @@
 import type { UmbControllerHost } from './controller-host.interface.js';
 import type { ClassConstructor } from '../extension-api/index.js';
-interface UmbControllerHostBaseDeclaration extends Omit<UmbControllerHost, 'getHostElement'> {
+export interface UmbControllerHostBaseDeclaration extends Omit<UmbControllerHost, 'getHostElement'> {
     hostConnected(): void;
     hostDisconnected(): void;
     destroy(): void;
@@ -13,4 +13,3 @@ interface UmbControllerHostBaseDeclaration extends Omit<UmbControllerHost, 'getH
  * @returns {UmbControllerHost} - A class which extends the given superclass.
  */
 export declare const UmbControllerHostMixin: <T extends ClassConstructor>(superClass: T) => ClassConstructor<UmbControllerHostBaseDeclaration> & T;
-export {};

package/dist-cms/libs/controller-api/element-controller-host.d.ts

@@ -0,0 +1,15 @@
+declare const UmbElementControllerHost_base: import("../extension-api/index.js").ClassConstructor<import("./controller-host.mixin.js").UmbControllerHostBaseDeclaration> & {
+    new (): {};
+};
+/**
+ * A controller host backed by a DOM element.
+ * Enables providing contexts and hosting controllers on elements that are not UmbLitElements.
+ * @class UmbElementControllerHost
+ */
+export declare class UmbElementControllerHost extends UmbElementControllerHost_base {
+    #private;
+    constructor(element: Element);
+    getHostElement(): Element;
+    destroy(): void;
+}
+export {};

package/dist-cms/libs/controller-api/element-controller-host.js

@@ -0,0 +1,21 @@
+import { UmbControllerHostMixin } from './controller-host.mixin.js';
+/**
+ * A controller host backed by a DOM element.
+ * Enables providing contexts and hosting controllers on elements that are not UmbLitElements.
+ * @class UmbElementControllerHost
+ */
+export class UmbElementControllerHost extends UmbControllerHostMixin(class {
+}) {
+    #element;
+    constructor(element) {
+        super();
+        this.#element = element;
+    }
+    getHostElement() {
+        return this.#element;
+    }
+    destroy() {
+        super.destroy();
+        this.#element = undefined;
+    }
+}

package/dist-cms/libs/controller-api/index.d.ts

@@ -2,6 +2,7 @@ export * from './controller-host.mixin.js';
 export type * from './controller-host.interface.js';
 export type * from './controller-host-element.interface.js';
 export * from './controller-host-element.mixin.js';
+export * from './element-controller-host.js';
 export type * from './controller.interface.js';
 export type * from './controller-alias.type.js';
 export * from './controller.event.js';

package/dist-cms/libs/controller-api/index.js

@@ -1,3 +1,4 @@
 export * from './controller-host.mixin.js';
 export * from './controller-host-element.mixin.js';
+export * from './element-controller-host.js';
 export * from './controller.event.js';

package/dist-cms/libs/observable-api/states/basic-state.d.ts

@@ -1,3 +1,5 @@
+import type { MappingFunction } from '../types/mapping-function.type.js';
+import type { MemoizationFunction } from '../types/memoization-function.type.js';
 import { BehaviorSubject, type Observable } from '../../../external/rxjs/index.js';
 /**
  * @class UmbBasicState
@@ -16,6 +18,14 @@ export declare class UmbBasicState<T> {
      * this.observe(myState, (latestStateValue) => console.log("Value is: ", latestStateValue));
      */
     asObservable(): Observable<T>;
+    /**
+     * @function asObservablePart
+     * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
+     * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to compare if the data has changed. Should return true when data is identical.
+     * @returns {Observable<R>}
+     * @description - Creates an Observable from this State that emits a derived value, deduplicated against its previous emission.
+     */
+    asObservablePart<ReturnType>(mappingFunction: MappingFunction<T, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): Observable<ReturnType>;
     /**
      * @property {unknown} value - the value of the State.
      * @description - Holds the current data of this state.

package/dist-cms/libs/observable-api/states/basic-state.js

@@ -1,4 +1,6 @@
+import { createObservablePart } from '../utils/create-observable-part.function.js';
 import { BehaviorSubject } from '../../../external/rxjs/index.js';
+import { strictEqualityMemoization } from '../utils/strict-equality-memoization.function.js';
 /**
  * @class UmbBasicState
  * @description - State ensures the data is unique, not updating any Observes unless there is an actual change of the value using `===`.
@@ -19,6 +21,16 @@ export class UmbBasicState {
     asObservable() {
         return this._subject.asObservable();
     }
+    /**
+     * @function asObservablePart
+     * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
+     * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to compare if the data has changed. Should return true when data is identical.
+     * @returns {Observable<R>}
+     * @description - Creates an Observable from this State that emits a derived value, deduplicated against its previous emission.
+     */
+    asObservablePart(mappingFunction, memoizationFunction) {
+        return createObservablePart(this._subject, mappingFunction, memoizationFunction ?? strictEqualityMemoization);
+    }
     /**
      * @property {unknown} value - the value of the State.
      * @description - Holds the current data of this state.
@@ -60,7 +72,9 @@ export class UmbBasicState {
      * // myState.value is equal 'Goodnight'.
      */
     setValue(data) {
-        if (this._subject && data !== this._subject.getValue()) {
+        if (!this._subject)
+            throw new Error('_subject is undefined');
+        if (data !== this._subject.getValue()) {
             this._subject.next(data);
         }
     }

package/dist-cms/libs/observable-api/states/class-state.d.ts

@@ -1,3 +1,4 @@
+import type { Observable } from '../../../external/rxjs/index.js';
 import type { MappingFunction } from '../types/mapping-function.type.js';
 import type { MemoizationFunction } from '../types/memoization-function.type.js';
 import type { UmbClassStateData } from '../utils/class-equal-memoization.function.js';
@@ -12,11 +13,11 @@ export declare class UmbClassState<T extends UmbClassStateData | undefined> exte
     /**
      * @function createObservablePart
      * @param {(mappable: UmbClassStateData | undefined) => unknown} mappingFunction - Method to return the part for this Observable to return.
-     * @param {(previousResult: unknown, currentResult: unknown) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
+     * @param {(previousResult: unknown, currentResult: unknown) => boolean} [memoizationFunction] - Method to compare two results. Should return true when data is the same (unchanged), preventing unnecessary emissions.
      * @returns {Observable<unknown>} - an observable.
      * @description - Creates an Observable from this State.
      */
-    asObservablePart<ReturnType>(mappingFunction: MappingFunction<T, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): import("rxjs").Observable<ReturnType>;
+    asObservablePart<ReturnType>(mappingFunction: MappingFunction<T, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): Observable<ReturnType>;
     /**
      * @function setValue
      * @param {UmbClassStateData | undefined} data - The next data for this state to hold.

package/dist-cms/libs/observable-api/states/class-state.js

@@ -12,7 +12,7 @@ export class UmbClassState extends UmbBasicState {
     /**
      * @function createObservablePart
      * @param {(mappable: UmbClassStateData | undefined) => unknown} mappingFunction - Method to return the part for this Observable to return.
-     * @param {(previousResult: unknown, currentResult: unknown) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
+     * @param {(previousResult: unknown, currentResult: unknown) => boolean} [memoizationFunction] - Method to compare two results. Should return true when data is the same (unchanged), preventing unnecessary emissions.
      * @returns {Observable<unknown>} - an observable.
      * @description - Creates an Observable from this State.
      */
@@ -26,8 +26,12 @@ export class UmbClassState extends UmbBasicState {
      */
     setValue(data) {
         if (!this._subject)
-            return;
+            throw new Error('_subject is undefined');
         const oldValue = this._subject.getValue();
+        // Do a strict compare first, to avoid reacting on the same instance or going from undefined to undefined.
+        if (data === oldValue)
+            return;
+        // Then if the current value has an equal method, use it to compare with the incoming value.
         if (data && oldValue?.equal(data))
             return;
         this._subject.next(data);

package/dist-cms/libs/observable-api/states/deep-state.d.ts

@@ -1,6 +1,7 @@
 import type { MappingFunction } from '../types/mapping-function.type.js';
 import type { MemoizationFunction } from '../types/memoization-function.type.js';
 import { UmbBasicState } from './basic-state.js';
+import type { Observable } from '../../../external/rxjs/index.js';
 /**
  * @class UmbDeepState
  * @augments {BehaviorSubject<T>}
@@ -13,11 +14,11 @@ export declare class UmbDeepState<T> extends UmbBasicState<T> {
     /**
      * @function createObservablePart
      * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
-     * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
+     * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to compare two results. Should return true when data is the same (unchanged), preventing unnecessary emissions.
      * @returns {Observable<R>}
      * @description - Creates an Observable from this State.
      */
-    asObservablePart<ReturnType>(mappingFunction: MappingFunction<T, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): import("rxjs").Observable<ReturnType>;
+    asObservablePart<ReturnType>(mappingFunction: MappingFunction<T, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): Observable<ReturnType>;
     /**
      * @function setValue
      * @param {T} data - The next data for this state to hold.
@@ -40,11 +41,12 @@ export declare class UmbDeepState<T> extends UmbBasicState<T> {
      * @description - Check if the state is muted.
      * @returns {boolean} - Returns true if the state is muted.
      */
-    isMuted(): boolean | undefined;
+    isMuted(): boolean;
     /**
      * @function getMutePromise
      * @description - Get a promise which resolves when the mute is unset.
-     * @returns {Promise<void>}
+     * @returns {Promise<boolean>} - Returns a promise which resolves to true if the state was muted and is now unmuted, or false if the state was not muted.
      */
-    getMutePromise(): Promise<void>;
+    getMutePromise(): Promise<boolean>;
+    destroy(): void;
 }

package/dist-cms/libs/observable-api/states/deep-state.js

@@ -11,6 +11,7 @@ import { UmbBasicState } from './basic-state.js';
 export class UmbDeepState extends UmbBasicState {
     #mute;
     #value;
+    #muteResolvers;
     constructor(initialData) {
         super(deepFreeze(initialData));
         this.#value = this._subject.getValue();
@@ -18,7 +19,7 @@ export class UmbDeepState extends UmbBasicState {
     /**
      * @function createObservablePart
      * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
-     * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
+     * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to compare two results. Should return true when data is the same (unchanged), preventing unnecessary emissions.
      * @returns {Observable<R>}
      * @description - Creates an Observable from this State.
      */
@@ -32,7 +33,7 @@ export class UmbDeepState extends UmbBasicState {
      */
     setValue(data) {
         if (!this._subject)
-            return;
+            throw new Error('_subject is undefined');
         const frozenData = deepFreeze(data);
         this.#value = frozenData;
         // Only update data if its not muted and is different than current data. [NL]
@@ -61,8 +62,16 @@ export class UmbDeepState extends UmbBasicState {
             return;
         this.#mute = false;
         // Only update data if it is different than current data. [NL]
+        if (!this._subject)
+            throw new Error('_subject is undefined');
         if (!jsonStringComparison(this.#value, this._subject.getValue())) {
-            this._subject?.next(this.#value);
+            this._subject.next(this.#value);
+        }
+        // Resolve any pending mute promises — independent of whether an emission occurred. [NL]
+        if ((this.#muteResolvers?.length ?? 0) > 0) {
+            const resolvers = this.#muteResolvers;
+            this.#muteResolvers = [];
+            resolvers.forEach((resolve) => resolve(true));
         }
     }
     /**
@@ -71,23 +80,28 @@ export class UmbDeepState extends UmbBasicState {
      * @returns {boolean} - Returns true if the state is muted.
      */
     isMuted() {
-        return this.#mute;
+        return this.#mute ?? false;
     }
     /**
      * @function getMutePromise
      * @description - Get a promise which resolves when the mute is unset.
-     * @returns {Promise<void>}
+     * @returns {Promise<boolean>} - Returns a promise which resolves to true if the state was muted and is now unmuted, or false if the state was not muted.
      */
     getMutePromise() {
+        if (!this.#mute) {
+            return Promise.resolve(false);
+        }
         return new Promise((resolve) => {
-            if (!this.#mute) {
-                resolve();
-                return;
-            }
-            const subscription = this._subject.subscribe(() => {
-                subscription.unsubscribe();
-                resolve();
-            });
+            (this.#muteResolvers ??= []).push(resolve);
         });
     }
+    destroy() {
+        // Drain any pending mute promises so awaiters don't hang. [NL]
+        if ((this.#muteResolvers?.length ?? 0) > 0) {
+            const resolvers = this.#muteResolvers;
+            this.#muteResolvers = [];
+            resolvers.forEach((resolve) => resolve(false));
+        }
+        super.destroy();
+    }
 }

package/dist-cms/libs/observable-api/states/string-state.d.ts

@@ -1,4 +1,3 @@
-import type { MappingFunction, MemoizationFunction } from '../types/index.js';
 import { UmbBasicState } from './basic-state.js';
 /**
  * @class UmbStringState
@@ -7,5 +6,4 @@ import { UmbBasicState } from './basic-state.js';
  */
 export declare class UmbStringState<T> extends UmbBasicState<T | string> {
     constructor(initialData: T | string);
-    asObservablePart<ReturnType>(mappingFunction: MappingFunction<T | string, ReturnType>, memoizationFunction?: MemoizationFunction<ReturnType>): import("rxjs").Observable<ReturnType>;
 }

package/dist-cms/libs/observable-api/states/string-state.js

@@ -1,4 +1,3 @@
-import { createObservablePart, strictEqualityMemoization } from '../utils/index.js';
 import { UmbBasicState } from './basic-state.js';
 /**
  * @class UmbStringState
@@ -9,7 +8,4 @@ export class UmbStringState extends UmbBasicState {
     constructor(initialData) {
         super(initialData);
     }
-    asObservablePart(mappingFunction, memoizationFunction) {
-        return createObservablePart(this._subject, mappingFunction, memoizationFunction ?? strictEqualityMemoization);
-    }
 }

package/dist-cms/libs/observable-api/utils/create-observable-part.function.d.ts

@@ -5,7 +5,7 @@ import type { Observable } from '../../../external/rxjs/index.js';
  * @function createObservablePart
  * @param {Observable<T>} source - RxJS Subject to use for this Observable.
  * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
- * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
+ * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to compare two results. Should return true when data is the same (unchanged), preventing unnecessary emissions.
  * @returns {Observable<T>}
  * @description - Creates a RxJS Observable from RxJS Subject.
  * @example <caption>Example create a Observable for part of the data Subject.</caption>

package/dist-cms/libs/observable-api/utils/create-observable-part.function.js

@@ -4,7 +4,7 @@ import { distinctUntilChanged, map, shareReplay } from '../../../external/rxjs/i
  * @function createObservablePart
  * @param {Observable<T>} source - RxJS Subject to use for this Observable.
  * @param {(mappable: T) => R} mappingFunction - Method to return the part for this Observable to return.
- * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to Compare if the data has changed. Should return true when data is different.
+ * @param {(previousResult: R, currentResult: R) => boolean} [memoizationFunction] - Method to compare two results. Should return true when data is the same (unchanged), preventing unnecessary emissions.
  * @returns {Observable<T>}
  * @description - Creates a RxJS Observable from RxJS Subject.
  * @example <caption>Example create a Observable for part of the data Subject.</caption>

package/dist-cms/packages/block/block/action/block-action-base.d.ts

@@ -0,0 +1,13 @@
+import type { UmbBlockActionArgs } from './types.js';
+import type { UmbBlockAction } from './block-action.interface.js';
+import { UmbActionBase } from '../../../core/action/index.js';
+/**
+ * Base class for block action API implementations.
+ * Provides default no-op implementations of getHref(), execute(), and getValidationDataPath().
+ * Subclasses override only the methods they need.
+ */
+export declare abstract class UmbBlockActionBase<ArgsMetaType> extends UmbActionBase<UmbBlockActionArgs<ArgsMetaType>> implements UmbBlockAction<ArgsMetaType> {
+    getHref(): Promise<string | undefined>;
+    execute(): Promise<void>;
+    getValidationDataPath(): Promise<string | undefined>;
+}

package/dist-cms/packages/block/block/action/block-action-base.js

@@ -0,0 +1,17 @@
+import { UmbActionBase } from '../../../core/action/index.js';
+/**
+ * Base class for block action API implementations.
+ * Provides default no-op implementations of getHref(), execute(), and getValidationDataPath().
+ * Subclasses override only the methods they need.
+ */
+export class UmbBlockActionBase extends UmbActionBase {
+    getHref() {
+        return Promise.resolve(undefined);
+    }
+    execute() {
+        return Promise.resolve();
+    }
+    getValidationDataPath() {
+        return Promise.resolve(undefined);
+    }
+}

package/dist-cms/packages/block/block/action/block-action-element.interface.d.ts

@@ -0,0 +1,4 @@
+import type { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+/** Element interface for block action UI components. */
+export interface UmbBlockActionElement extends UmbControllerHostElement {
+}

package/dist-cms/packages/block/block/action/block-action-list.element.d.ts

@@ -0,0 +1,20 @@
+import { nothing } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+/**
+ * Renders registered blockAction extensions inside a uui-action-bar.
+ * Filters actions by block editor type and content type alias.
+ * @element umb-block-action-list
+ */
+export declare class UmbBlockActionListElement extends UmbLitElement {
+    #private;
+    blockEditor?: string;
+    private _showActions?;
+    private _actions;
+    constructor();
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-block-action-list': UmbBlockActionListElement;
+    }
+}

package/dist-cms/packages/block/block/action/block-action-list.element.js

@@ -0,0 +1,78 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+import { UMB_BLOCK_ENTRY_CONTEXT } from '../context/block-entry.context-token.js';
+import { customElement, html, nothing, property, repeat, state } from '../../../../external/lit/index.js';
+import { observeMultiple } from '../../../../libs/observable-api/index.js';
+import { stringOrStringArrayContains } from '../../../core/utils/index.js';
+import { UmbExtensionsElementAndApiInitializer } from '../../../../libs/extension-api/index.js';
+import { umbExtensionsRegistry } from '../../../core/extension-registry/index.js';
+import { UmbLitElement } from '../../../core/lit-element/index.js';
+/**
+ * Renders registered blockAction extensions inside a uui-action-bar.
+ * Filters actions by block editor type and content type alias.
+ * @element umb-block-action-list
+ */
+let UmbBlockActionListElement = class UmbBlockActionListElement extends UmbLitElement {
+    #unique;
+    #contentTypeAlias;
+    constructor() {
+        super();
+        this._actions = [];
+        this.consumeContext(UMB_BLOCK_ENTRY_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.observe(observeMultiple([context.unique, context.contentElementTypeAlias, context.actionsVisibility]), ([unique, contentTypeAlias, showActions]) => {
+                this._showActions = showActions;
+                const hasChanged = this.#unique !== unique || this.#contentTypeAlias !== contentTypeAlias;
+                this.#unique = unique ?? undefined;
+                this.#contentTypeAlias = contentTypeAlias ?? undefined;
+                if (hasChanged) {
+                    this.#initExtensions();
+                }
+            });
+        });
+    }
+    #initExtensions() {
+        if (!this.#unique)
+            return;
+        // Re-create the initializer so the filter closure captures the latest #contentTypeAlias and #unique.
+        this.removeUmbControllerByAlias('blockActionsInitializer');
+        new UmbExtensionsElementAndApiInitializer(this, umbExtensionsRegistry, 'blockAction', (manifest) => [{ unique: this.#unique, meta: manifest.meta }], (manifest) => this.#filterExtension(manifest), (actions) => (this._actions = actions), 'blockActionsInitializer');
+    }
+    #filterExtension(manifest) {
+        if (manifest.forContentTypeAlias &&
+            !stringOrStringArrayContains(manifest.forContentTypeAlias, this.#contentTypeAlias ?? '')) {
+            return false;
+        }
+        if (manifest.forBlockEditor && !stringOrStringArrayContains(manifest.forBlockEditor, this.blockEditor ?? '')) {
+            return false;
+        }
+        return true;
+    }
+    render() {
+        if (!this._showActions)
+            return nothing;
+        return html `
+			<uui-action-bar>
+				${repeat(this._actions, (action) => action.alias, (action) => action.component)}
+			</uui-action-bar>
+		`;
+    }
+};
+__decorate([
+    property({ type: String, attribute: 'block-editor' })
+], UmbBlockActionListElement.prototype, "blockEditor", void 0);
+__decorate([
+    state()
+], UmbBlockActionListElement.prototype, "_showActions", void 0);
+__decorate([
+    state()
+], UmbBlockActionListElement.prototype, "_actions", void 0);
+UmbBlockActionListElement = __decorate([
+    customElement('umb-block-action-list')
+], UmbBlockActionListElement);
+export { UmbBlockActionListElement };

package/dist-cms/packages/block/block/action/block-action.extension.d.ts

@@ -0,0 +1,36 @@
+import type { UmbBlockActionElement } from './block-action-element.interface.js';
+import type { UmbBlockAction } from './block-action.interface.js';
+import type { ManifestElementAndApi, ManifestWithDynamicConditions } from '../../../../libs/extension-api/index.js';
+/**
+ * Manifest for a block action extension. Block actions appear in the action bar of block entries
+ * (Block List, Block Grid, Block RTE, Block Single) and can be registered by both internal and
+ * third-party extensions. Use `forBlockEditor` and `forContentTypeAlias` to filter which blocks
+ * the action appears on.
+ */
+export interface ManifestBlockAction<MetaType extends MetaBlockAction = MetaBlockAction> extends ManifestElementAndApi<UmbBlockActionElement, UmbBlockAction<MetaType>>, ManifestWithDynamicConditions<UmbExtensionConditionConfig> {
+    type: 'blockAction';
+    /**
+     * @description Optional filter to only show this action for specific Content Types by alias.
+     * @example 'my-element-type-alias'
+     * @example ['my-element-type-alias-A', 'my-element-type-alias-B']
+     */
+    forContentTypeAlias?: string | Array<string>;
+    /**
+     * @description Optional filter to only show this action for specific Block Editors.
+     * @example 'block-list'
+     * @example ['block-list', 'block-grid']
+     */
+    forBlockEditor?: string | Array<string>;
+    meta: MetaType;
+}
+/**
+ * Base metadata interface for block actions. Extend this to add custom metadata properties
+ * for specific block action kinds.
+ */
+export interface MetaBlockAction {
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        umbBlockAction: ManifestBlockAction;
+    }
+}

package/dist-cms/packages/block/block/action/block-action.extension.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/packages/block/block/action/block-action.interface.d.ts

@@ -0,0 +1,22 @@
+import type { UmbBlockActionArgs } from './types.js';
+import type { UmbAction } from '../../../core/action/index.js';
+export interface UmbBlockAction<ArgsMetaType> extends UmbAction<UmbBlockActionArgs<ArgsMetaType>> {
+    /**
+     * The href location, the action will act as a link.
+     * The `execute` method will not be called.
+     * @returns {Promise<string | undefined>}
+     */
+    getHref(): Promise<string | undefined>;
+    /**
+     * The `execute` method, the action will act as a button.
+     * @returns {Promise<void>}
+     */
+    execute(): Promise<void>;
+    /**
+     * Optional validation data path for displaying an invalid badge on the action button.
+     * When provided, the default kind element creates a validation state controller
+     * and renders a badge when validation messages exist at the given path.
+     * @returns {Promise<string | undefined>}
+     */
+    getValidationDataPath(): Promise<string | undefined>;
+}

package/dist-cms/packages/block/block/action/block-action.interface.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/packages/block/block/action/common/copy-to-clipboard/constants.d.ts

@@ -0,0 +1 @@
+export declare const UMB_BLOCK_ACTION_COPY_TO_CLIPBOARD_ALIAS = "Umb.BlockAction.CopyToClipboard";

package/dist-cms/packages/block/block/action/common/copy-to-clipboard/constants.js

@@ -0,0 +1 @@
+export const UMB_BLOCK_ACTION_COPY_TO_CLIPBOARD_ALIAS = 'Umb.BlockAction.CopyToClipboard';

package/dist-cms/packages/block/block/action/common/copy-to-clipboard/copy-to-clipboard-block.action.d.ts

@@ -0,0 +1,13 @@
+import type { MetaBlockActionDefaultKind } from '../../default/types.js';
+import type { UmbBlockActionArgs } from '../../types.js';
+import { UmbBlockActionBase } from '../../block-action-base.js';
+import type { UmbControllerHost } from '../../../../../../libs/controller-api/index.js';
+/**
+ * Block action that copies the block entry data to the clipboard via `context.copyToClipboard()`.
+ */
+export declare class UmbCopyToClipboardBlockAction extends UmbBlockActionBase<MetaBlockActionDefaultKind> {
+    #private;
+    constructor(host: UmbControllerHost, args: UmbBlockActionArgs<MetaBlockActionDefaultKind>);
+    execute(): Promise<void>;
+}
+export { UmbCopyToClipboardBlockAction as api };

package/dist-cms/packages/block/block/action/common/copy-to-clipboard/copy-to-clipboard-block.action.js

@@ -0,0 +1,18 @@
+import { UmbBlockActionBase } from '../../block-action-base.js';
+import { UMB_BLOCK_ENTRY_CONTEXT } from '../../../context/block-entry.context-token.js';
+/**
+ * Block action that copies the block entry data to the clipboard via `context.copyToClipboard()`.
+ */
+export class UmbCopyToClipboardBlockAction extends UmbBlockActionBase {
+    #blockEntryContext;
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_BLOCK_ENTRY_CONTEXT, (context) => {
+            this.#blockEntryContext = context;
+        });
+    }
+    async execute() {
+        await this.#blockEntryContext?.copyToClipboard();
+    }
+}
+export { UmbCopyToClipboardBlockAction as api };

package/dist-cms/packages/block/block/action/common/copy-to-clipboard/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/block/block/action/common/copy-to-clipboard/manifests.js

@@ -0,0 +1,15 @@
+import { UMB_BLOCK_ACTION_COPY_TO_CLIPBOARD_ALIAS } from './constants.js';
+export const manifests = [
+    {
+        type: 'blockAction',
+        kind: 'default',
+        alias: UMB_BLOCK_ACTION_COPY_TO_CLIPBOARD_ALIAS,
+        name: 'Copy to Clipboard Block Action',
+        weight: 200,
+        api: () => import('./copy-to-clipboard-block.action.js'),
+        meta: {
+            icon: 'icon-clipboard-copy',
+            label: '#clipboard_labelForCopyToClipboard',
+        },
+    },
+];

package/dist-cms/packages/block/block/action/common/delete/constants.d.ts

@@ -0,0 +1 @@
+export declare const UMB_BLOCK_ACTION_DELETE_ALIAS = "Umb.BlockAction.Delete";

package/dist-cms/packages/block/block/action/common/delete/constants.js

@@ -0,0 +1 @@
+export const UMB_BLOCK_ACTION_DELETE_ALIAS = 'Umb.BlockAction.Delete';