@umbraco-engage/backoffice 17.0.0-rc1

package/dist/core/actions/entity-actions-bundle.js

@@ -0,0 +1,169 @@
+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 { html, nothing, customElement, property, state, ifDefined, css, } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { umbExtensionsRegistry } from "@umbraco-cms/backoffice/extension-registry";
+import { UmbExtensionsManifestInitializer, createExtensionApi, } from "@umbraco-cms/backoffice/extension-api";
+import { UmbEntityContext } from "@umbraco-cms/backoffice/entity";
+// This is 'borrowed' from the CMS's `umb-entity-actions-bundle` and modified to only show the ... more button if more than two actions exist.
+// This is used on the persona and journey editor, to display the edit and delete buttons
+// TODO => consider a CMS PR to enable same in core and remove the need for the custom element.
+let UeEntityActionsBundleElement = class UeEntityActionsBundleElement extends UmbLitElement {
+    // TODO: provide the entity context on a higher level, like the root element of this entity, tree-item/workspace/... [NL]
+    #entityContext;
+    #inViewport;
+    #observingEntityActions;
+    constructor() {
+        super();
+        this._numberOfActions = 0;
+        // TODO: provide the entity context on a higher level, like the root element of this entity, tree-item/workspace/... [NL]
+        this.#entityContext = new UmbEntityContext(this);
+        this.#inViewport = false;
+        this.#observingEntityActions = false;
+        // Only observe entity actions when the element is in the viewport
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach((entry) => {
+                if (entry.isIntersecting) {
+                    this.#inViewport = true;
+                    this.#observeEntityActions();
+                }
+            });
+        }, {
+            root: null, // Use the viewport as the root
+            threshold: 0.1, // Trigger when at least 10% of the element is visible
+        });
+        observer.observe(this);
+    }
+    updated(_changedProperties) {
+        if (_changedProperties.has("entityType") &&
+            _changedProperties.has("unique")) {
+            this.#entityContext.setEntityType(this.entityType);
+            this.#entityContext.setUnique(this.unique ?? null);
+            this.#observeEntityActions();
+        }
+    }
+    #observeEntityActions() {
+        if (!this.entityType)
+            return;
+        if (this.unique === undefined)
+            return;
+        if (!this.#inViewport)
+            return; // Only observe if the element is in the viewport
+        if (this.#observingEntityActions)
+            return;
+        new UmbExtensionsManifestInitializer(this, umbExtensionsRegistry, "entityAction", (ext) => ext.forEntityTypes.includes(this.entityType), async (actions) => {
+            this._numberOfActions = actions.length;
+            this._firstActionManifest =
+                this._numberOfActions > 0
+                    ? actions[0].manifest
+                    : undefined;
+            this._secondActionManifest =
+                this._numberOfActions === 2
+                    ? actions[1].manifest
+                    : undefined;
+            this.#createActionApi(this._firstActionManifest, (x) => (this._firstActionApi = x), (x) => (this._firstActionHref = x));
+            this.#createActionApi(this._secondActionManifest, (x) => (this._secondActionApi = x), (x) => (this._secondActionHref = x));
+        }, "umbEntityActionsObserver");
+        this.#observingEntityActions = true;
+    }
+    async #createActionApi(manifest, apiSetter, hrefSetter) {
+        if (!manifest)
+            return;
+        const api = await createExtensionApi(this, manifest, [
+            {
+                unique: this.unique,
+                entityType: this.entityType,
+                meta: manifest.meta,
+            },
+        ]);
+        if (api) {
+            api.manifest = manifest;
+            const href = await api.getHref();
+            apiSetter?.(api);
+            if (hrefSetter && href)
+                hrefSetter(href);
+        }
+    }
+    async #onActionClick(event, api, href) {
+        if (href) {
+            return;
+        }
+        event.stopPropagation();
+        await api?.execute().catch(() => { });
+    }
+    render() {
+        if (this._numberOfActions === 0)
+            return nothing;
+        return html `<uui-action-bar slot="actions"
+      >${this._numberOfActions > 2 ? this.#renderMore() : null}
+      ${this.#renderAction(this._firstActionApi, this._firstActionManifest, this._firstActionHref)}
+      ${this._numberOfActions === 2
+            ? this.#renderAction(this._secondActionApi, this._secondActionManifest, this._secondActionHref)
+            : null}
+    </uui-action-bar>`;
+    }
+    #renderMore() {
+        return html `
+      <umb-entity-actions-dropdown .label=${this.label} compact>
+        <uui-symbol-more slot="label"></uui-symbol-more>
+      </umb-entity-actions-dropdown>
+    `;
+    }
+    #renderAction(api, manifest, href) {
+        if (!api || !manifest)
+            return nothing;
+        return html `<uui-button
+      label=${this.localize.string(manifest.meta.label)}
+      data-mark=${"entity-action:" + manifest.alias}
+      @click=${(e) => this.#onActionClick(e, api, href)}
+      href="${ifDefined(href)}"
+    >
+      <uui-icon name=${ifDefined(manifest.meta.icon)}></uui-icon>
+    </uui-button>`;
+    }
+    static { this.styles = [
+        css `
+      uui-scroll-container {
+        max-height: 700px;
+      }
+    `,
+    ]; }
+};
+__decorate([
+    property({ type: String, attribute: "entity-type" })
+], UeEntityActionsBundleElement.prototype, "entityType", void 0);
+__decorate([
+    property({ type: String })
+], UeEntityActionsBundleElement.prototype, "unique", void 0);
+__decorate([
+    property({ type: String })
+], UeEntityActionsBundleElement.prototype, "label", void 0);
+__decorate([
+    state()
+], UeEntityActionsBundleElement.prototype, "_numberOfActions", void 0);
+__decorate([
+    state()
+], UeEntityActionsBundleElement.prototype, "_firstActionManifest", void 0);
+__decorate([
+    state()
+], UeEntityActionsBundleElement.prototype, "_firstActionApi", void 0);
+__decorate([
+    state()
+], UeEntityActionsBundleElement.prototype, "_firstActionHref", void 0);
+__decorate([
+    state()
+], UeEntityActionsBundleElement.prototype, "_secondActionManifest", void 0);
+__decorate([
+    state()
+], UeEntityActionsBundleElement.prototype, "_secondActionApi", void 0);
+__decorate([
+    state()
+], UeEntityActionsBundleElement.prototype, "_secondActionHref", void 0);
+UeEntityActionsBundleElement = __decorate([
+    customElement("ue-entity-actions-bundle")
+], UeEntityActionsBundleElement);
+export { UeEntityActionsBundleElement };

package/dist/core/actions/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./entity-actions-bundle.js";
+export * from "./action-event.js";
+export * from "./save-workspace-action.js";
+export * from "./submit-workspace-action.js";

package/dist/core/actions/index.js

@@ -0,0 +1,4 @@
+export * from "./entity-actions-bundle.js";
+export * from "./action-event.js";
+export * from "./save-workspace-action.js";
+export * from "./submit-workspace-action.js";

package/dist/core/actions/save-workspace-action.d.ts

@@ -0,0 +1,4 @@
+import { UmbSaveWorkspaceAction } from "@umbraco-cms/backoffice/workspace";
+export declare class UeSaveWorkspaceAction extends UmbSaveWorkspaceAction {
+    execute(): Promise<void>;
+}

package/dist/core/actions/save-workspace-action.js

@@ -0,0 +1,15 @@
+import { UMB_ACTION_EVENT_CONTEXT } from "@umbraco-cms/backoffice/action";
+import { UmbSaveWorkspaceAction } from "@umbraco-cms/backoffice/workspace";
+import { UeEntityActionEvent } from "./action-event.js";
+export class UeSaveWorkspaceAction extends UmbSaveWorkspaceAction {
+    async execute() {
+        await super.execute();
+        const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
+        if (!eventContext)
+            throw new Error("Event context not found.");
+        eventContext.dispatchEvent(new UeEntityActionEvent({
+            entityType: this._workspaceContext?.getEntityType() ?? "",
+            unique: this._workspaceContext?.getUnique() ?? "",
+        }));
+    }
+}

package/dist/core/actions/submit-workspace-action.d.ts

@@ -0,0 +1,4 @@
+import { UmbSaveWorkspaceAction } from "@umbraco-cms/backoffice/workspace";
+export declare class UeSubmitWorkspaceAction extends UmbSaveWorkspaceAction {
+    execute(): Promise<void>;
+}

package/dist/core/actions/submit-workspace-action.js

@@ -0,0 +1,25 @@
+import { UMB_ACTION_EVENT_CONTEXT } from "@umbraco-cms/backoffice/action";
+import { UmbSaveWorkspaceAction } from "@umbraco-cms/backoffice/workspace";
+import { UeEntityActionEvent } from "./action-event.js";
+import { UMB_MODAL_CONTEXT } from "@umbraco-cms/backoffice/modal";
+export class UeSubmitWorkspaceAction extends UmbSaveWorkspaceAction {
+    async execute() {
+        await super.execute();
+        const unique = this._workspaceContext?.getUnique();
+        if (!unique)
+            return;
+        const entityType = this._workspaceContext?.getEntityType();
+        if (!entityType)
+            return;
+        const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
+        if (!eventContext)
+            throw new Error("Event context not found.");
+        eventContext.dispatchEvent(new UeEntityActionEvent({
+            entityType,
+            unique,
+        }));
+        // because this extends the save action, we need to manually close the modal
+        const modalContext = await this.getContext(UMB_MODAL_CONTEXT);
+        modalContext?.submit();
+    }
+}

package/dist/core/collection/collection-create-action.element.d.ts

@@ -0,0 +1,15 @@
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import type { ManifestUeCollectionAction } from "../index.js";
+declare const elementName = "ue-create-entity-collection-action";
+export declare class UeCreateEntityCollectionActionElement extends UmbLitElement {
+    private _createPath;
+    manifest?: ManifestUeCollectionAction;
+    constructor();
+    render(): import("lit-html").TemplateResult<1>;
+}
+export default UeCreateEntityCollectionActionElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        [elementName]: UeCreateEntityCollectionActionElement;
+    }
+}

package/dist/core/collection/collection-create-action.element.js

@@ -0,0 +1,47 @@
+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_COLLECTION_CONTEXT } from "@umbraco-cms/backoffice/collection";
+import { customElement, html, property, state, } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+const elementName = "ue-create-entity-collection-action";
+let UeCreateEntityCollectionActionElement = class UeCreateEntityCollectionActionElement extends UmbLitElement {
+    constructor() {
+        super();
+        this._createPath = "";
+        this.consumeContext(UMB_COLLECTION_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.observe(context.workspacePathBuilder, (builder) => {
+                if (!builder || !this.manifest)
+                    return;
+                this._createPath = builder({
+                    entityType: this.manifest.meta.entityType,
+                });
+            });
+        });
+    }
+    render() {
+        return html `
+      <uui-button
+        label=${this.localize.string(this.manifest?.meta.label ?? "#general_create")}
+        href=${`${this._createPath}create`}
+        look="outline"
+      ></uui-button>
+    `;
+    }
+};
+__decorate([
+    state()
+], UeCreateEntityCollectionActionElement.prototype, "_createPath", void 0);
+__decorate([
+    property({ attribute: false })
+], UeCreateEntityCollectionActionElement.prototype, "manifest", void 0);
+UeCreateEntityCollectionActionElement = __decorate([
+    customElement(elementName)
+], UeCreateEntityCollectionActionElement);
+export { UeCreateEntityCollectionActionElement };
+export default UeCreateEntityCollectionActionElement;

package/dist/core/collection/collection-default.element.d.ts

@@ -0,0 +1,12 @@
+import { UmbCollectionDefaultElement } from "@umbraco-cms/backoffice/collection";
+declare const elementName = "ue-default-collection";
+export declare class UeCollectionDefaultElement extends UmbCollectionDefaultElement {
+    updated(): void;
+    static styles: import("lit").CSSResult[];
+}
+export default UeCollectionDefaultElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        [elementName]: UeCollectionDefaultElement;
+    }
+}

package/dist/core/collection/collection-default.element.js

@@ -0,0 +1,36 @@
+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 { UmbCollectionDefaultElement } from "@umbraco-cms/backoffice/collection";
+import { css, customElement } from "@umbraco-cms/backoffice/external/lit";
+const elementName = "ue-default-collection";
+let UeCollectionDefaultElement = class UeCollectionDefaultElement extends UmbCollectionDefaultElement {
+    // TODO => this is a hack to hide the box-shadow on the collection header
+    // We could consider rolling our own collections entirely, or look at a CMS PR
+    // to make this more easily customisable, based on the rendering context for the collection
+    updated() {
+        const node = this.shadowRoot?.querySelector("umb-body-layout");
+        if (!node)
+            return;
+        const header = node.shadowRoot?.querySelector("#header");
+        header?.style.setProperty("box-shadow", "none");
+    }
+    static { this.styles = [
+        ...UmbCollectionDefaultElement.styles,
+        css `
+      :host {
+        --uui-size-layout-1: var(--uui-size-7);
+        margin: 0 calc(-1 * var(--uui-size-layout-1));
+        margin-top: 3px;
+      }
+    `,
+    ]; }
+};
+UeCollectionDefaultElement = __decorate([
+    customElement(elementName)
+], UeCollectionDefaultElement);
+export { UeCollectionDefaultElement };
+export default UeCollectionDefaultElement;

package/dist/core/collection/collection-table-base.element.d.ts

@@ -0,0 +1,23 @@
+import type { UeEntityBase } from "../entities.js";
+import { type UmbDefaultCollectionContext } from "@umbraco-cms/backoffice/collection";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import type { UmbTableColumn, UmbTableConfig, UmbTableItem } from "@umbraco-cms/backoffice/components";
+export declare abstract class UeCollectionTableBaseElement<ModelType extends UeEntityBase = UeEntityBase> extends UmbLitElement {
+    #private;
+    protected collectionContext?: UmbDefaultCollectionContext<ModelType>;
+    protected loading: boolean;
+    protected modalPath?: string;
+    protected tableItems: Array<UmbTableItem>;
+    private _tableConfig;
+    protected tableColumns: Array<UmbTableColumn>;
+    private _selection;
+    protected _entityType: string;
+    abstract createTableItems(items: ModelType[]): any;
+    abstract createTableColumns(): any;
+    constructor(args: {
+        tableConfig?: UmbTableConfig;
+        entityType: string;
+    });
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}

package/dist/core/collection/collection-table-base.element.js

@@ -0,0 +1,112 @@
+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_COLLECTION_CONTEXT, } from "@umbraco-cms/backoffice/collection";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { css, html, state, when } from "@umbraco-cms/backoffice/external/lit";
+export class UeCollectionTableBaseElement extends UmbLitElement {
+    constructor(args) {
+        super();
+        this.loading = true;
+        this.tableItems = [];
+        this._tableConfig = {
+            allowSelection: true,
+            hideIcon: true,
+        };
+        this.tableColumns = [];
+        this._selection = [];
+        this.createTableColumns();
+        if (args.tableConfig) {
+            this._tableConfig = args.tableConfig;
+        }
+        this._entityType = args.entityType;
+        this.consumeContext(UMB_COLLECTION_CONTEXT, (instance) => {
+            if (!instance)
+                return;
+            this.collectionContext = instance;
+            instance.setupView(this);
+            this.observe(instance.workspacePathBuilder, (builder) => {
+                if (!builder)
+                    return;
+                this.modalPath = builder({ entityType: this._entityType });
+                this.#observeCollectionItems();
+            });
+        });
+    }
+    async #observeCollectionItems() {
+        if (!this.collectionContext)
+            return;
+        this.observe(this.collectionContext.items, (collectionItems) => {
+            this.createTableItems(collectionItems);
+            // Reconcile selection: remove IDs not present in items (e.g. after deletion of items)
+            const itemIds = collectionItems.map((item) => item.unique);
+            const filteredSelection = this._selection.filter((id) => itemIds.includes(id));
+            if (filteredSelection.length !== this._selection.length) {
+                this.collectionContext?.selection.setSelection(filteredSelection);
+            }
+        }, Symbol("engageCollectionItemsObserver"));
+        this.observe(this.collectionContext?.selection.selection, (selection) => (this._selection = selection), Symbol("engageCollectionSelectionObserver"));
+        this.observe(this.collectionContext.loading, (loading) => (this.loading = loading), Symbol("engageCollectionLoadingObserver"));
+    }
+    #onSelected(event) {
+        event.stopPropagation();
+        const table = event.target;
+        const selection = table.selection;
+        this.collectionContext?.selection.setSelection(selection);
+    }
+    #onDeselected(event) {
+        event.stopPropagation();
+        const table = event.target;
+        const selection = table.selection;
+        this.collectionContext?.selection.setSelection(selection);
+    }
+    #renderTable() {
+        return when(this.tableItems.length, () => html `
+        <umb-table
+          .config=${this._tableConfig}
+          .columns=${this.tableColumns}
+          .items=${this.tableItems}
+          .selection=${this._selection}
+          @selected=${this.#onSelected}
+          @deselected=${this.#onDeselected}
+        ></umb-table>
+      `);
+    }
+    render() {
+        return when(this.loading, () => html `<uui-loader-bar></uui-loader-bar>`, () => this.#renderTable());
+    }
+    static { this.styles = [
+        css `
+      :host {
+        display: flex;
+        flex-direction: column;
+      }
+
+      .flex {
+        display: flex;
+        justify-content: center;
+      }
+    `,
+    ]; }
+}
+__decorate([
+    state()
+], UeCollectionTableBaseElement.prototype, "loading", void 0);
+__decorate([
+    state()
+], UeCollectionTableBaseElement.prototype, "modalPath", void 0);
+__decorate([
+    state()
+], UeCollectionTableBaseElement.prototype, "tableItems", void 0);
+__decorate([
+    state()
+], UeCollectionTableBaseElement.prototype, "_tableConfig", void 0);
+__decorate([
+    state()
+], UeCollectionTableBaseElement.prototype, "tableColumns", void 0);
+__decorate([
+    state()
+], UeCollectionTableBaseElement.prototype, "_selection", void 0);

package/dist/core/collection/entity-delete.action.d.ts

@@ -0,0 +1,6 @@
+import { UmbEntityBulkActionBase } from "@umbraco-cms/backoffice/entity-bulk-action";
+import type { MetaUeEntityBulkActionDeleteKind } from "../extension-manifests/index.js";
+export declare class UeCollectionDeleteBulkAction<MetaKindType extends MetaUeEntityBulkActionDeleteKind = MetaUeEntityBulkActionDeleteKind> extends UmbEntityBulkActionBase<MetaKindType> {
+    execute(): Promise<void>;
+}
+export { UeCollectionDeleteBulkAction as api };

package/dist/core/collection/entity-delete.action.js

@@ -0,0 +1,47 @@
+import { UmbEntityBulkActionBase } from "@umbraco-cms/backoffice/entity-bulk-action";
+import { umbConfirmModal } from "@umbraco-cms/backoffice/modal";
+import { UmbLocalizationController } from "@umbraco-cms/backoffice/localization-api";
+import { createExtensionApiByAlias } from "@umbraco-cms/backoffice/extension-registry";
+import { UMB_NOTIFICATION_CONTEXT } from "@umbraco-cms/backoffice/notification";
+import { UMB_ACTION_EVENT_CONTEXT } from "@umbraco-cms/backoffice/action";
+import { UMB_COLLECTION_CONTEXT } from "@umbraco-cms/backoffice/collection";
+import { UeBulkActionDeleteEvent } from "./entity-delete.event.js";
+export class UeCollectionDeleteBulkAction extends UmbEntityBulkActionBase {
+    async execute() {
+        if (this.selection?.length === 0)
+            return;
+        const localize = new UmbLocalizationController(this);
+        await umbConfirmModal(this._host, {
+            headline: localize.term("actions_delete"),
+            content: localize.term("engage_deleteItemsDescription", this.selection.length),
+            color: "danger",
+            confirmLabel: localize.term("actions_delete"),
+        });
+        const repository = await createExtensionApiByAlias(this, this.args.meta.repositoryAlias);
+        const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+        const succeeded = [];
+        for (const unique of this.selection) {
+            const { error } = await repository.delete(unique);
+            if (error) {
+                const notification = { data: { message: error.message } };
+                notificationContext?.peek("danger", notification);
+            }
+            else {
+                succeeded.push(unique);
+            }
+        }
+        const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
+        if (!eventContext) {
+            throw new Error("Could not find context: UMB_ACTION_EVENT_CONTEXT");
+        }
+        eventContext.dispatchEvent(new UeBulkActionDeleteEvent({
+            entityType: this.args.meta.entityType,
+            deletedItems: succeeded,
+        }));
+        const collectionContext = await this.getContext(UMB_COLLECTION_CONTEXT);
+        if (!collectionContext)
+            return;
+        await collectionContext.requestCollection();
+    }
+}
+export { UeCollectionDeleteBulkAction as api };

package/dist/core/collection/entity-delete.event.d.ts

@@ -0,0 +1,13 @@
+import { UmbControllerEvent } from "@umbraco-cms/backoffice/controller-api";
+interface UeBulkActionDeleteEventArgs {
+    entityType: string;
+    deletedItems: Array<string>;
+}
+export declare class UeBulkActionDeleteEvent<ArgsType extends UeBulkActionDeleteEventArgs = UeBulkActionDeleteEventArgs> extends UmbControllerEvent {
+    static readonly TYPE = "bulk-action-delete";
+    protected _args: ArgsType;
+    constructor(args: ArgsType);
+    getEntityType(): string;
+    getDeletedItems(): Array<string>;
+}
+export {};

package/dist/core/collection/entity-delete.event.js

@@ -0,0 +1,14 @@
+import { UmbControllerEvent } from "@umbraco-cms/backoffice/controller-api";
+export class UeBulkActionDeleteEvent extends UmbControllerEvent {
+    static { this.TYPE = "bulk-action-delete"; }
+    constructor(args) {
+        super(UeBulkActionDeleteEvent.TYPE);
+        this._args = args;
+    }
+    getEntityType() {
+        return this._args.entityType;
+    }
+    getDeletedItems() {
+        return this._args.deletedItems;
+    }
+}

package/dist/core/collection/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./entity-delete.action.js";
+export * from "./entity-delete.event.js";
+export * from "./collection-default.element.js";
+export * from "./collection-table-base.element.js";
+export * from "./table-name-column-layout.element.js";

package/dist/core/collection/index.js

@@ -0,0 +1,5 @@
+export * from "./entity-delete.action.js";
+export * from "./entity-delete.event.js";
+export * from "./collection-default.element.js";
+export * from "./collection-table-base.element.js";
+export * from "./table-name-column-layout.element.js";

package/dist/core/collection/manifests.d.ts

@@ -0,0 +1,2 @@
+import type { UmbExtensionManifestKind } from "@umbraco-cms/backoffice/extension-registry";
+export declare const manifests: Array<UmbExtensionManifest | UmbExtensionManifestKind>;

package/dist/core/collection/manifests.js

@@ -0,0 +1,32 @@
+export const manifests = [
+    {
+        type: "kind",
+        alias: "Engage.Kind.CollectionAction.Create",
+        matchKind: "engage-create",
+        matchType: "collectionAction",
+        manifest: {
+            type: "collectionAction",
+            kind: "engage-create",
+            element: () => import("./collection-create-action.element.js"),
+            weight: 1200,
+            meta: {
+                label: "#actions_create",
+            },
+        },
+    },
+    {
+        type: "kind",
+        alias: "Engage.Kind.EntityBulkAction.Delete",
+        matchKind: "engage-delete",
+        matchType: "entityBulkAction",
+        manifest: {
+            type: "entityBulkAction",
+            kind: "engage-delete",
+            api: () => import("./entity-delete.action.js"),
+            weight: 1100,
+            meta: {
+                label: "#actions_delete",
+            },
+        },
+    },
+];

package/dist/core/collection/table-name-column-layout.element.d.ts

@@ -0,0 +1,21 @@
+import { nothing } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+declare const elementName = "ue-table-name-column-layout";
+export declare class UeTableNameColumnLayoutElement extends UmbLitElement {
+    #private;
+    value: {
+        name: string;
+        description: string;
+        unique: string;
+        modalPath: string;
+        footer?: string;
+    };
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        [elementName]: UeTableNameColumnLayoutElement;
+    }
+}
+export default UeTableNameColumnLayoutElement;