@umbraco-cms/backoffice 14.0.0-e72b5840 → 14.0.0-ef334a6d

package/dist-cms/mocks/data/document-type.data.js

@@ -471,63 +471,6 @@ export const data = [
                     labelOnTop: false,
                 },
             },
-            {
-                id: '24',
-                containerId: 'all-properties-group-key',
-                alias: 'numberRange',
-                name: 'Number Range',
-                description: '',
-                dataTypeId: 'dt-numberRange',
-                variesByCulture: false,
-                variesBySegment: false,
-                validation: {
-                    mandatory: true,
-                    mandatoryMessage: null,
-                    regEx: null,
-                    regExMessage: null,
-                },
-                appearance: {
-                    labelOnTop: false,
-                },
-            },
-            {
-                id: '25',
-                containerId: 'all-properties-group-key',
-                alias: 'orderDirection',
-                name: 'Order Direction',
-                description: '',
-                dataTypeId: 'dt-orderDirection',
-                variesByCulture: false,
-                variesBySegment: false,
-                validation: {
-                    mandatory: true,
-                    mandatoryMessage: null,
-                    regEx: null,
-                    regExMessage: null,
-                },
-                appearance: {
-                    labelOnTop: false,
-                },
-            },
-            {
-                id: '26',
-                containerId: 'all-properties-group-key',
-                alias: 'overlaySize',
-                name: 'Overlay Size',
-                description: '',
-                dataTypeId: 'dt-overlaySize',
-                variesByCulture: false,
-                variesBySegment: false,
-                validation: {
-                    mandatory: true,
-                    mandatoryMessage: null,
-                    regEx: null,
-                    regExMessage: null,
-                },
-                appearance: {
-                    labelOnTop: false,
-                },
-            },
             {
                 id: '27',
                 containerId: 'all-properties-group-key',
@@ -807,11 +750,11 @@ export const data = [
         ],
         compositions: [
             {
-                id: '5035d7d9-0a63-415c-9e75-ee2cf931db92',
+                id: '8f68ba66-6fb2-4778-83b8-6ab4ca3a7c5d',
                 compositionType: ContentTypeCompositionTypeModel.INHERITANCE,
             },
             {
-                id: '8f68ba66-6fb2-4778-83b8-6ab4ca3a7c5d',
+                id: '5035d7d9-0a63-415c-9e75-ee2cf931db92',
                 compositionType: ContentTypeCompositionTypeModel.COMPOSITION,
             },
         ],

package/dist-cms/mocks/data/log-viewer.data.d.ts

@@ -5,11 +5,11 @@ declare class UmbLogViewerSearchesData extends UmbData<SavedLogSearchResponseMod
     getSavedSearches(skip?: number, take?: number): Array<SavedLogSearchResponseModel>;
     getByName(name: string): import("../../external/backend-api/index.js").SavedLogSearchPresenationBaseModel | undefined;
 }
-declare class UmbLogviewerTemplatesData extends UmbData<LogTemplateResponseModel> {
+declare class UmbLogViewerTemplatesData extends UmbData<LogTemplateResponseModel> {
     constructor(data: LogTemplateResponseModel[]);
     getTemplates(skip?: number, take?: number): Array<LogTemplateResponseModel>;
 }
-declare class UmbLogviewerMessagesData extends UmbData<LogMessageResponseModel> {
+declare class UmbLogViewerMessagesData extends UmbData<LogMessageResponseModel> {
     constructor(data: LogTemplateResponseModel[]);
     getLogs(skip?: number, take?: number): Array<LogMessageResponseModel>;
     getLevelCount(): {};
@@ -25,8 +25,8 @@ export declare const logLevels: {
 };
 export declare const umbLogViewerData: {
     searches: UmbLogViewerSearchesData;
-    templates: UmbLogviewerTemplatesData;
-    logs: UmbLogviewerMessagesData;
+    templates: UmbLogViewerTemplatesData;
+    logs: UmbLogViewerMessagesData;
     logLevels: {
         total: number;
         items: {

package/dist-cms/mocks/data/log-viewer.data.js

@@ -13,7 +13,7 @@ class UmbLogViewerSearchesData extends UmbData {
         return this.data.find((search) => search.name === name);
     }
 }
-class UmbLogviewerTemplatesData extends UmbData {
+class UmbLogViewerTemplatesData extends UmbData {
     constructor(data) {
         super(data);
     }
@@ -22,7 +22,7 @@ class UmbLogviewerTemplatesData extends UmbData {
         return this.data.slice(skip, take);
     }
 }
-class UmbLogviewerMessagesData extends UmbData {
+class UmbLogViewerMessagesData extends UmbData {
     constructor(data) {
         super(data);
     }
@@ -380,7 +380,7 @@ export const logLevels = {
 };
 export const umbLogViewerData = {
     searches: new UmbLogViewerSearchesData(savedSearches),
-    templates: new UmbLogviewerTemplatesData(messageTemplates),
-    logs: new UmbLogviewerMessagesData(logs),
+    templates: new UmbLogViewerTemplatesData(messageTemplates),
+    logs: new UmbLogViewerMessagesData(logs),
     logLevels: logLevels,
 };

package/dist-cms/mocks/handlers/manifests.handlers.js

@@ -30,7 +30,7 @@ export const manifestDevelopmentHandler = rest.get(umbracoPath('/package/manifes
                         label: 'My Custom Property',
                         icon: 'document',
                         group: 'Common',
-                        propertyEditorSchema: 'Umbraco.JSON',
+                        propertyEditorSchema: 'Umbraco.TextBox',
                     },
                 },
             ],

package/dist-cms/packages/core/collection/collection.context.d.ts

@@ -25,4 +25,4 @@ export declare class UmbCollectionContext<ItemType, FilterModelType extends UmbC
     requestCollection(): Promise<void>;
     setFilter(filter: Partial<FilterModelType>): void;
 }
-export declare const UMB_COLLECTION_CONTEXT_TOKEN: UmbContextToken<UmbCollectionContext<any, any>>;
+export declare const UMB_COLLECTION_CONTEXT_TOKEN: UmbContextToken<UmbCollectionContext<any, any>, UmbCollectionContext<any, any>>;

package/dist-cms/packages/core/components/entity-actions-bundle/entity-actions-bundle.element.js

@@ -33,7 +33,7 @@ export let UmbEntityActionsBundleElement = class UmbEntityActionsBundleElement e
     #observeEntityActions() {
         this.observe(umbExtensionsRegistry
             .extensionsOfType('entityAction')
-            .pipe(map((actions) => actions.filter((action) => action.conditions.entityTypes.includes(this.entityType)))), (actions) => {
+            .pipe(map((actions) => actions.filter((action) => action.meta.entityTypes.includes(this.entityType)))), (actions) => {
             this._hasActions = actions.length > 0;
         }, 'observeEntityAction');
     }

package/dist-cms/packages/core/components/extension-slot/extension-slot.element.d.ts

@@ -1,13 +1,9 @@
 import { TemplateResult } from '../../../../external/lit/index.js';
+import { type UmbExtensionElementController } from '../../../../libs/extension-api/index.js';
 import { UmbLitElement } from '../../../../shared/lit-element/index.js';
-export type InitializedExtension = {
-    alias: string;
-    weight: number;
-    component: HTMLElement | null;
-};
 /**
  * @element umb-extension-slot
- * @description
+ * @description A element which renderers the extensions of a given type or types.
  * @slot default - slot for inserting additional things into this slot.
  * @export
  * @class UmbExtensionSlot
@@ -15,18 +11,46 @@ export type InitializedExtension = {
  */
 export declare class UmbExtensionSlotElement extends UmbLitElement {
     #private;
-    private _extensions;
-    type: string;
-    filter: (manifest: any) => boolean;
-    private _props?;
-    get props(): Record<string, any> | undefined;
-    set props(newVal: Record<string, any> | undefined);
+    private _permittedExts;
+    /**
+     * The type or types of extensions to render.
+     * @type {string | string[]}
+     * @memberof UmbExtensionSlot
+     * @example
+     * <umb-extension-slot type="my-extension-type"></umb-extension-slot>
+     * or multiple:
+     * <umb-extension-slot .type=${['my-extension-type','another-extension-type']}></umb-extension-slot>
+     *
+     */
+    get type(): string | string[] | undefined;
+    set type(value: string | string[] | undefined);
+    /**
+     * Filter method for extension manifests.
+     * This is an initial filter taking effect before conditions or overwrites, the extensions will still be filtered by the conditions defined in the manifest.
+     * @type {(manifest: any) => boolean}
+     * @memberof UmbExtensionSlot
+     * @example
+     * <umb-extension-slot type="my-extension-type" .filter=${(ext) => ext.meta.anyPropToFilter === 'foo'}></umb-extension-slot>
+     *
+     */
+    get filter(): (manifest: any) => boolean;
+    set filter(value: (manifest: any) => boolean);
+    /**
+     * Properties to pass to the extensions elements.
+     * Notice: The individual manifest of the extension is parsed to each extension element no matter if this is set or not.
+     * @type {Record<string, any>}
+     * @memberof UmbExtensionSlot
+     * @example
+     * <umb-extension-slot type="my-extension-type" .props=${{foo: 'bar'}}></umb-extension-slot>
+     */
+    get props(): Record<string, unknown> | undefined;
+    set props(newVal: Record<string, unknown> | undefined);
     defaultElement: string;
-    renderMethod?: (extension: InitializedExtension) => TemplateResult<1 | 2> | HTMLElement | null;
+    renderMethod?: (extension: UmbExtensionElementController) => TemplateResult | HTMLElement | null | undefined;
     connectedCallback(): void;
     private _observeExtensions;
     render(): unknown;
-    static styles: import("@lit/reactive-element/css-tag").CSSResult;
+    static styles: import("@lit/reactive-element/css-tag.js").CSSResult;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist-cms/packages/core/components/extension-slot/extension-slot.element.js

@@ -4,99 +4,109 @@ 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;
 };
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { css, repeat, customElement, property, state } from '../../../../external/lit/index.js';
-import { map } from '../../../../external/rxjs/index.js';
-import { createExtensionElement, isManifestElementableType } from '../../../../libs/extension-api/index.js';
 import { umbExtensionsRegistry } from '../../extension-registry/index.js';
+import { css, repeat, customElement, property, state } from '../../../../external/lit/index.js';
+import { UmbExtensionsElementController, } from '../../../../libs/extension-api/index.js';
 import { UmbLitElement } from '../../../../shared/lit-element/index.js';
 /**
  * @element umb-extension-slot
- * @description
+ * @description A element which renderers the extensions of a given type or types.
  * @slot default - slot for inserting additional things into this slot.
  * @export
  * @class UmbExtensionSlot
  * @extends {UmbLitElement}
  */
+// TODO: Fire change event.
+// TODO: Make property that reveals the amount of displayed/permitted extensions.
 export let UmbExtensionSlotElement = class UmbExtensionSlotElement extends UmbLitElement {
     constructor() {
         super(...arguments);
-        this._extensions = [];
-        this.type = '';
-        this.filter = () => true;
-        this._props = {};
+        this.#attached = false;
+        this._permittedExts = [];
+        this.#filter = () => true;
+        this.#props = {};
         this.defaultElement = '';
-        this.#assignProps = (component) => {
-            if (!component || !this._props)
-                return;
-            Object.keys(this._props).forEach((key) => {
-                component[key] = this._props?.[key];
-            });
-        };
     }
+    #attached;
+    #extensionsController;
+    /**
+     * The type or types of extensions to render.
+     * @type {string | string[]}
+     * @memberof UmbExtensionSlot
+     * @example
+     * <umb-extension-slot type="my-extension-type"></umb-extension-slot>
+     * or multiple:
+     * <umb-extension-slot .type=${['my-extension-type','another-extension-type']}></umb-extension-slot>
+     *
+     */
+    get type() {
+        return this.#type;
+    }
+    set type(value) {
+        if (value === this.#type)
+            return;
+        this.#type = value;
+        if (this.#attached) {
+            this._observeExtensions();
+        }
+    }
+    #type;
+    /**
+     * Filter method for extension manifests.
+     * This is an initial filter taking effect before conditions or overwrites, the extensions will still be filtered by the conditions defined in the manifest.
+     * @type {(manifest: any) => boolean}
+     * @memberof UmbExtensionSlot
+     * @example
+     * <umb-extension-slot type="my-extension-type" .filter=${(ext) => ext.meta.anyPropToFilter === 'foo'}></umb-extension-slot>
+     *
+     */
+    get filter() {
+        return this.#filter;
+    }
+    set filter(value) {
+        if (value === this.#filter)
+            return;
+        this.#filter = value;
+        if (this.#attached) {
+            this._observeExtensions();
+        }
+    }
+    #filter;
+    /**
+     * Properties to pass to the extensions elements.
+     * Notice: The individual manifest of the extension is parsed to each extension element no matter if this is set or not.
+     * @type {Record<string, any>}
+     * @memberof UmbExtensionSlot
+     * @example
+     * <umb-extension-slot type="my-extension-type" .props=${{foo: 'bar'}}></umb-extension-slot>
+     */
     get props() {
-        return this._props;
+        return this.#props;
     }
     set props(newVal) {
-        this._props = newVal;
-        // TODO: we could optimize this so we only re-set the updated props.
-        this.#assignPropsToAllComponents();
+        // TODO, compare changes since last time. only reset the ones that changed. This might be better done by the controller is self:
+        this.#props = newVal;
+        if (this.#extensionsController) {
+            this.#extensionsController.properties = newVal;
+        }
     }
+    #props;
     connectedCallback() {
         super.connectedCallback();
         this._observeExtensions();
+        this.#attached = true;
     }
     _observeExtensions() {
-        this.observe(umbExtensionsRegistry?.extensionsOfType(this.type).pipe(map((extensions) => extensions.filter(this.filter))), async (extensions) => {
-            const oldValue = this._extensions;
-            const oldLength = this._extensions.length;
-            this._extensions = this._extensions.filter((current) => extensions.find((incoming) => incoming.alias === current.alias));
-            if (this._extensions.length !== oldLength) {
-                this.requestUpdate('_extensions', oldValue);
-            }
-            extensions.forEach(async (extension) => {
-                const hasExt = this._extensions.find((x) => x.alias === extension.alias);
-                if (!hasExt) {
-                    const extensionObject = {
-                        alias: extension.alias,
-                        weight: extension.weight || 0,
-                        component: null,
-                    };
-                    this._extensions.push(extensionObject);
-                    // sort:
-                    this._extensions.sort((a, b) => b.weight - a.weight);
-                    let component;
-                    if (isManifestElementableType(extension)) {
-                        component = await createExtensionElement(extension);
-                    }
-                    else if (this.defaultElement) {
-                        component = document.createElement(this.defaultElement);
-                    }
-                    else {
-                        // TODO: Lets make an console.error in this case?
-                    }
-                    if (component) {
-                        this.#assignProps(component);
-                        component.manifest = extension;
-                        extensionObject.component = component;
-                    }
-                    else {
-                        // Remove cause we could not get the component, so we will get rid of this.
-                        //this._extensions.splice(this._extensions.indexOf(extensionObject), 1);
-                        // Actually not, because if, then the same extension would come around again in next update.
-                    }
-                    this.requestUpdate('_extensions', oldValue);
-                }
-            });
-        });
-    }
-    #assignPropsToAllComponents() {
-        this._extensions.forEach((ext) => this.#assignProps(ext.component));
+        this.#extensionsController?.destroy();
+        if (this.#type) {
+            this.#extensionsController = new UmbExtensionsElementController(this, umbExtensionsRegistry, this.#type, this.filter, (extensionControllers) => {
+                this._permittedExts = extensionControllers;
+            }, this.defaultElement);
+            this.#extensionsController.properties = this.#props;
+        }
     }
-    #assignProps;
     render() {
-        // TODO: check if we can use repeat directly.
-        return repeat(this._extensions, (ext) => ext.alias, (ext) => (this.renderMethod ? this.renderMethod(ext) : ext.component));
+        return repeat(this._permittedExts, (ext) => ext.alias, (ext) => (this.renderMethod ? this.renderMethod(ext) : ext.component));
     }
     static { this.styles = css `
 		:host {
@@ -106,13 +116,13 @@ export let UmbExtensionSlotElement = class UmbExtensionSlotElement extends UmbLi
 };
 __decorate([
     state()
-], UmbExtensionSlotElement.prototype, "_extensions", void 0);
+], UmbExtensionSlotElement.prototype, "_permittedExts", void 0);
 __decorate([
     property({ type: String })
-], UmbExtensionSlotElement.prototype, "type", void 0);
+], UmbExtensionSlotElement.prototype, "type", null);
 __decorate([
     property({ type: Object, attribute: false })
-], UmbExtensionSlotElement.prototype, "filter", void 0);
+], UmbExtensionSlotElement.prototype, "filter", null);
 __decorate([
     property({ type: Object, attribute: false })
 ], UmbExtensionSlotElement.prototype, "props", null);

package/dist-cms/packages/core/components/property-type-based-property/property-type-based-property.element.js

@@ -7,8 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { UUITextStyles } from '../../../../external/uui/index.js';
 import { css, html, ifDefined, customElement, property, state } from '../../../../external/lit/index.js';
 import { UmbDataTypeRepository } from '../../../settings/data-types/index.js';
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from '../../../documents/documents/index.js';
 import { UmbLitElement } from '../../../../shared/lit-element/index.js';
-import { UMB_ENTITY_WORKSPACE_CONTEXT } from '../../workspace/index.js';
 import { umbExtensionsRegistry } from '../../extension-registry/index.js';
 export let UmbPropertyTypeBasedPropertyElement = class UmbPropertyTypeBasedPropertyElement extends UmbLitElement {
     get property() {
@@ -43,7 +43,7 @@ export let UmbPropertyTypeBasedPropertyElement = class UmbPropertyTypeBasedPrope
     constructor() {
         super();
         this._dataTypeRepository = new UmbDataTypeRepository(this);
-        this.consumeContext(UMB_ENTITY_WORKSPACE_CONTEXT, (workspaceContext) => {
+        this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, (workspaceContext) => {
             this._workspaceContext = workspaceContext;
             this._observeProperty();
         });

package/dist-cms/packages/core/content-type/content-type-property-structure-helper.class.d.ts

@@ -8,6 +8,7 @@ export declare class UmbContentTypePropertyStructureHelper {
     private _containerName?;
     readonly propertyStructure: import("rxjs").Observable<PropertyTypeModelBaseModel[]>;
     constructor(host: UmbControllerHostElement);
+    getOwnerDocumentTypes(): import("rxjs").Observable<import("../../../external/backend-api/index.js").DocumentTypeResponseModel[]> | undefined;
     setStructureManager(structure: UmbContentTypePropertyStructureManager): void;
     setContainerType(value?: PropertyContainerTypes): void;
     getContainerType(): PropertyContainerTypes | undefined;
@@ -18,6 +19,7 @@ export declare class UmbContentTypePropertyStructureHelper {
     private _observeGroupContainers;
     private _observePropertyStructureOf;
     /** Manipulate methods: */
+    createPropertyScaffold(ownerId?: string, sortOrder?: number): Promise<PropertyTypeModelBaseModel | undefined>;
     addProperty(ownerId?: string, sortOrder?: number): Promise<PropertyTypeModelBaseModel | undefined>;
     insertProperty(property: PropertyTypeModelBaseModel, sortOrder?: number): Promise<boolean>;
     removeProperty(propertyId: string): Promise<boolean>;

package/dist-cms/packages/core/content-type/content-type-property-structure-helper.class.js

@@ -15,6 +15,9 @@ export class UmbContentTypePropertyStructureHelper {
         // TODO: Remove as any when sortOrder is implemented:
         this.#propertyStructure.sortBy((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
     }
+    getOwnerDocumentTypes() {
+        return this.#structure?.documentTypes;
+    }
     setStructureManager(structure) {
         this.#structure = structure;
         this.#initResolver?.(undefined);
@@ -77,6 +80,12 @@ export class UmbContentTypePropertyStructureHelper {
     }
     // TODO: consider moving this to another class, to separate 'viewer' from 'manipulator':
     /** Manipulate methods: */
+    async createPropertyScaffold(ownerId, sortOrder) {
+        await this.#init;
+        if (!this.#structure)
+            return;
+        return await this.#structure.createPropertyScaffold(ownerId, sortOrder);
+    }
     async addProperty(ownerId, sortOrder) {
         await this.#init;
         if (!this.#structure)

package/dist-cms/packages/core/content-type/content-type-structure-manager.class.d.ts

@@ -37,6 +37,7 @@ export declare class UmbContentTypePropertyStructureManager<R extends UmbDetailR
     makeContainerNameUniqueForOwnerDocument(newName: string, containerType?: PropertyContainerTypes, parentId?: string | null): string | null;
     updateContainer(documentTypeId: string | null, containerId: string, partialUpdate: Partial<PropertyTypeContainerModelBaseModel>): Promise<void>;
     removeContainer(documentTypeKey: string | null, containerId?: string | null): Promise<void>;
+    createPropertyScaffold(containerId?: string | null, sortOrder?: number): PropertyTypeModelBaseModel;
     createProperty(documentTypeId: string | null, containerId?: string | null, sortOrder?: number): Promise<PropertyTypeModelBaseModel>;
     insertProperty(documentTypeId: string | null, property: PropertyTypeModelBaseModel): Promise<void>;
     removeProperty(documentTypeId: string | null, propertyId: string): Promise<void>;

package/dist-cms/packages/core/content-type/content-type-structure-manager.class.js

@@ -139,10 +139,10 @@ export class UmbContentTypePropertyStructureManager {
         return container;
     }
     makeContainerNameUniqueForOwnerDocument(newName, containerType = 'Tab', parentId = null) {
-        const ownerRootContainers = this.getOwnerContainers(containerType, parentId);
+        const ownerRootContainers = this.getOwnerContainers(containerType); //getRootContainers() can't differentiates between compositions and locals
         let changedName = newName;
         if (ownerRootContainers) {
-            while (ownerRootContainers.find((tab) => tab.name === changedName)) {
+            while (ownerRootContainers.find((tab) => tab.name === changedName && tab.id !== parentId)) {
                 changedName = incrementString(changedName);
             }
             return changedName === newName ? null : changedName;
@@ -163,9 +163,7 @@ export class UmbContentTypePropertyStructureManager {
         const containers = frozenContainers.filter((x) => x.id !== containerId);
         this.#documentTypes.updateOne(documentTypeKey, { containers });
     }
-    async createProperty(documentTypeId, containerId = null, sortOrder) {
-        await this.#init;
-        documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
+    createPropertyScaffold(containerId = null, sortOrder) {
         const property = {
             id: UmbId.new(),
             containerId: containerId,
@@ -186,6 +184,12 @@ export class UmbContentTypePropertyStructureManager {
             },
             sortOrder: sortOrder ?? 0,
         }; // Sort order was not allowed when this was written.
+        return property;
+    }
+    async createProperty(documentTypeId, containerId = null, sortOrder) {
+        await this.#init;
+        documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
+        const property = this.createPropertyScaffold(containerId, sortOrder);
         const properties = [...(this.#documentTypes.getValue().find((x) => x.id === documentTypeId)?.properties ?? [])];
         properties.push(property);
         this.#documentTypes.updateOne(documentTypeId, { properties });
@@ -202,7 +206,7 @@ export class UmbContentTypePropertyStructureManager {
         await this.#init;
         documentTypeId = documentTypeId ?? this.#ownerDocumentTypeId;
         const frozenProperties = this.#documentTypes.getValue().find((x) => x.id === documentTypeId)?.properties ?? [];
-        const properties = filterFrozenArray(frozenProperties, (x) => x.id === propertyId);
+        const properties = filterFrozenArray(frozenProperties, (x) => x.id !== propertyId);
         this.#documentTypes.updateOne(documentTypeId, { properties });
     }
     async updateProperty(documentTypeId, propertyId, partialUpdate) {

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

@@ -1,12 +1,12 @@
+import { ManifestEntityAction } from '../extension-registry/index.js';
 import { UmbLitElement } from '../../../shared/lit-element/index.js';
 export declare class UmbEntityActionListElement extends UmbLitElement {
-    #private;
-    private _entityType;
     get entityType(): string;
     set entityType(value: string);
-    unique?: string;
-    private _entityActions?;
-    render(): import("lit-html").TemplateResult<1>;
+    private _entityType;
+    _filter?: (extension: ManifestEntityAction) => boolean;
+    unique?: string | null;
+    render(): "" | import("lit-html").TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist-cms/packages/core/entity-action/entity-action-list.element.js

@@ -5,8 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { html, customElement, property, state } from '../../../external/lit/index.js';
-import { map } from '../../../external/rxjs/index.js';
-import { umbExtensionsRegistry } from '../extension-registry/index.js';
 import { UmbLitElement } from '../../../shared/lit-element/index.js';
 export let UmbEntityActionListElement = class UmbEntityActionListElement extends UmbLitElement {
     constructor() {
@@ -17,36 +15,34 @@ export let UmbEntityActionListElement = class UmbEntityActionListElement extends
         return this._entityType;
     }
     set entityType(value) {
-        const oldValue = this._entityType;
+        if (value === this._entityType)
+            return;
         this._entityType = value;
-        if (oldValue !== this._entityType) {
-            this.#observeEntityActions();
-            this.requestUpdate('entityType', oldValue);
-        }
-    }
-    // TODO: find a solution to use extension slot
-    #observeEntityActions() {
-        this.observe(umbExtensionsRegistry.extensionsOfType('entityAction').pipe(map((extensions) => {
-            return extensions.filter((extension) => extension.conditions.entityTypes.includes(this.entityType));
-        })), (actions) => {
-            this._entityActions = actions;
-        });
+        const oldValue = this._filter;
+        this._filter = (extension) => extension.meta.entityTypes.includes(this.entityType);
+        this.requestUpdate('_filter', oldValue);
     }
     render() {
-        return html `
-			${this._entityActions?.map((manifest) => html `<umb-entity-action .unique=${this.unique} .manifest=${manifest}></umb-entity-action>`)}
-		`;
+        return this._filter
+            ? html `
+					<umb-extension-slot
+						type="entityAction"
+						default-element="umb-entity-action"
+						.filter=${this._filter}
+						.props=${{ unique: this.unique }}></umb-extension-slot>
+			  `
+            : '';
     }
 };
 __decorate([
     property({ type: String, attribute: 'entity-type' })
 ], UmbEntityActionListElement.prototype, "entityType", null);
+__decorate([
+    state()
+], UmbEntityActionListElement.prototype, "_filter", void 0);
 __decorate([
     property({ type: String })
 ], UmbEntityActionListElement.prototype, "unique", void 0);
-__decorate([
-    state()
-], UmbEntityActionListElement.prototype, "_entityActions", void 0);
 UmbEntityActionListElement = __decorate([
     customElement('umb-entity-action-list')
 ], UmbEntityActionListElement);

package/dist-cms/packages/core/extension-registry/conditions/index.d.ts

@@ -0,0 +1 @@
+export { UmbSwitchCondition } from './switch.condition.js';

package/dist-cms/packages/core/extension-registry/conditions/index.js

@@ -0,0 +1,4 @@
+export { UmbSwitchCondition } from './switch.condition.js';
+/*
+export { UmbSectionAliasCondition } from './section-alias.condition.js';
+*/

package/dist-cms/packages/core/extension-registry/conditions/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("../../../../libs/extension-api/types.js").ManifestCondition[];

package/dist-cms/packages/core/extension-registry/conditions/manifests.js

@@ -0,0 +1,3 @@
+import { manifest as switchConditionManifest } from './switch.condition.js';
+import { manifest as sectionAliasConditionManifest } from './section-alias.condition.js';
+export const manifests = [switchConditionManifest, sectionAliasConditionManifest];