@umbraco-engage/backoffice 17.0.0-rc1

package/dist/ab-testing/test/workspace/ab-testing-test-workspace-editor.element.js

@@ -0,0 +1,90 @@
+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, customElement, state, } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { ENGAGE_AB_TESTING_TEST_WORKSPACE_ALIAS } from "../constants.js";
+import { ENGAGE_AB_TESTING_TEST_WORKSPACE_CONTEXT } from "./ab-testing-test-workspace-context.token.js";
+import { umbExtensionsRegistry } from "@umbraco-cms/backoffice/extension-registry";
+import { UmbExtensionsManifestInitializer } from "@umbraco-cms/backoffice/extension-api";
+const elementName = "ue-ab-testing-test-workspace-editor";
+let UeAbTestingTestWorkspaceEditorElement = class UeAbTestingTestWorkspaceEditorElement extends UmbLitElement {
+    #workspaceContext;
+    constructor() {
+        super();
+        new UmbExtensionsManifestInitializer(this, umbExtensionsRegistry, "workspaceView", null, (workspaceViews) => {
+            const v = workspaceViews.map((view) => view.manifest);
+            this.#workspaceContext?.setActiveView(v.at(0)?.meta.pathname);
+        });
+        this.consumeContext(ENGAGE_AB_TESTING_TEST_WORKSPACE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.#workspaceContext = context;
+            this.observe(context.test, (test) => {
+                this._test = test;
+            });
+        });
+    }
+    async connectedCallback() {
+        super.connectedCallback();
+        const child = await this.waitForElement("umb-workspace-editor", this.shadowRoot);
+        if (!child?.shadowRoot)
+            return;
+        const router = await this.waitForElement("umb-router-slot", child.shadowRoot);
+        if (!router)
+            return;
+        router.addEventListener("change", (e) => this.#onChange(e));
+    }
+    #onChange(e) {
+        const activeViewPath = e.target
+            .localActiveViewPath;
+        if (!activeViewPath)
+            return;
+        this.#workspaceContext?.setActiveView(activeViewPath);
+    }
+    waitForElement(selector, host, timeoutMs = 10_000) {
+        return new Promise((resolve, reject) => {
+            // Check if it already exists
+            const existing = host.querySelector(selector);
+            if (existing) {
+                resolve(existing);
+                return;
+            }
+            const observer = new MutationObserver(() => {
+                const element = host.querySelector(selector);
+                if (element) {
+                    observer.disconnect();
+                    clearTimeout(timeoutId);
+                    resolve(element);
+                }
+            });
+            observer.observe(host, {
+                childList: true,
+                subtree: true,
+            });
+            const timeoutId = setTimeout(() => {
+                observer.disconnect();
+                reject(new Error(`Timeout waiting for element: ${selector}`));
+            }, timeoutMs);
+        });
+    }
+    render() {
+        return html `<umb-workspace-editor
+      main-no-padding
+      alias=${ENGAGE_AB_TESTING_TEST_WORKSPACE_ALIAS}
+      .headline=${this._test?.name ?? ""}
+    >
+    </umb-workspace-editor>`;
+    }
+};
+__decorate([
+    state()
+], UeAbTestingTestWorkspaceEditorElement.prototype, "_test", void 0);
+UeAbTestingTestWorkspaceEditorElement = __decorate([
+    customElement(elementName)
+], UeAbTestingTestWorkspaceEditorElement);
+export { UeAbTestingTestWorkspaceEditorElement };
+export default UeAbTestingTestWorkspaceEditorElement;

package/dist/ab-testing/test/workspace/ab-testing-test-workspace.context.d.ts

@@ -0,0 +1,30 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UeAbTestingTestDetailModel } from "../entities.js";
+import type { UeAbTestingTestDetailRepository } from "../repository/index.js";
+import { type AbTestDtoModel, type GoalDtoModel, type ReportingStatusModel } from "../../../generated/index.js";
+import { UeWorkspaceContextBase } from "../../../core/index.js";
+import { UeAbTestingProjectItemModel } from "src/ab-testing/project/entities.js";
+export declare class UeAbTestingTestWorkspaceContext extends UeWorkspaceContextBase<UeAbTestingTestDetailModel, UeAbTestingTestDetailRepository> {
+    #private;
+    readonly IS_VIEW_AWARE = true;
+    readonly IS_AB_TESTING_TEST_WORKSPACE_CONTEXT = true;
+    generationStatus: import("rxjs").Observable<ReportingStatusModel | undefined>;
+    mainGoals: import("rxjs").Observable<Record<number, GoalDtoModel> | undefined>;
+    test: import("rxjs").Observable<AbTestDtoModel | undefined>;
+    indication: import("rxjs").Observable<import("../../../generated/index.js").AbTestIndicationModel | null | undefined>;
+    variants: import("rxjs").Observable<import("../../../generated/index.js").AbTestDetailVariantInfoModel[] | null | undefined>;
+    isInvertedGoal: import("rxjs").Observable<boolean | undefined>;
+    projects: import("rxjs").Observable<UeAbTestingProjectItemModel[]>;
+    goals: import("rxjs").Observable<GoalDtoModel[]>;
+    activeView: import("rxjs").Observable<string | undefined>;
+    constructor(host: UmbControllerHost);
+    setActiveView(path?: string): void;
+    getTestVariants(): import("../../../generated/index.js").AbTestVariantDtoModel[];
+    load(id: string): Promise<import("@umbraco-cms/backoffice/repository").UmbRepositoryResponse<UeAbTestingTestDetailModel> | import("@umbraco-cms/backoffice/repository").UmbRepositoryResponseWithAsObservable<UeAbTestingTestDetailModel, UeAbTestingTestDetailModel>>;
+    createScaffold(): Promise<UeAbTestingTestDetailModel | undefined>;
+    delete(): Promise<void>;
+    updateTest(test: Partial<AbTestDtoModel>, save?: boolean): Promise<void>;
+    disableVariant(id: number): Promise<void>;
+    requestSave(next?: boolean): Promise<void>;
+}
+export { UeAbTestingTestWorkspaceContext as api };

package/dist/ab-testing/test/workspace/ab-testing-test-workspace.context.js

@@ -0,0 +1,146 @@
+import { partialUpdateFrozenArray, UmbArrayState, UmbObjectState, UmbStringState, } from "@umbraco-cms/backoffice/observable-api";
+import { tryExecute } from "@umbraco-cms/backoffice/resources";
+import { ENGAGE_AB_TESTING_TEST_ENTITY_TYPE, ENGAGE_AB_TESTING_TEST_WORKSPACE_ALIAS, } from "../constants.js";
+import { ENGAGE_AB_TESTING_TEST_DETAIL_REPOSITORY_ALIAS } from "../repository/detail/constants.js";
+import { UeAbTestingTestWorkspaceEditorElement } from "./ab-testing-test-workspace-editor.element.js";
+import { ABTestVariantService, GoalsService, ReportingService, } from "../../../generated/index.js";
+import { UeWorkspaceContextBase } from "../../../core/index.js";
+import { UMB_MODAL_CONTEXT } from "@umbraco-cms/backoffice/modal";
+import { UeAbTestingProjectItemRepository } from "src/packages.js";
+import { UMB_ENTITY_DETAIL_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/workspace";
+export class UeAbTestingTestWorkspaceContext extends UeWorkspaceContextBase {
+    #hostWorkspaceContext;
+    #projectItemRepository;
+    #generationStatus;
+    #mainGoals;
+    #projects;
+    #goals;
+    #activeView;
+    #scaffoldInit;
+    #init;
+    constructor(host) {
+        super(host, {
+            workspaceAlias: ENGAGE_AB_TESTING_TEST_WORKSPACE_ALIAS,
+            entityType: ENGAGE_AB_TESTING_TEST_ENTITY_TYPE,
+            detailRepositoryAlias: ENGAGE_AB_TESTING_TEST_DETAIL_REPOSITORY_ALIAS,
+            routedComponents: {
+                edit: UeAbTestingTestWorkspaceEditorElement,
+                create: UeAbTestingTestWorkspaceEditorElement,
+            },
+        });
+        this.IS_VIEW_AWARE = true;
+        this.IS_AB_TESTING_TEST_WORKSPACE_CONTEXT = true;
+        this.#projectItemRepository = new UeAbTestingProjectItemRepository(this);
+        this.#generationStatus = new UmbObjectState(undefined);
+        this.generationStatus = this.#generationStatus.asObservable();
+        this.#mainGoals = new UmbObjectState(undefined);
+        this.mainGoals = this.#mainGoals.asObservable();
+        this.test = this._data.createObservablePartOfCurrent((x) => x?.test);
+        this.indication = this._data.createObservablePartOfCurrent((x) => x?.indication);
+        this.variants = this._data.createObservablePartOfCurrent((x) => x?.variants);
+        this.isInvertedGoal = this._data.createObservablePartOfCurrent((x) => x?.isInvertedGoal);
+        this.#projects = new UmbArrayState([], (x) => x.unique);
+        this.projects = this.#projects.asObservable();
+        this.#goals = new UmbArrayState([], (x) => x.id);
+        this.goals = this.#goals.asObservable();
+        this.#activeView = new UmbStringState(undefined);
+        this.activeView = this.#activeView.asObservable();
+        this.consumeContext(UMB_ENTITY_DETAIL_WORKSPACE_CONTEXT, (context) => {
+            this.#hostWorkspaceContext = context;
+        }).skipHost();
+        this.#init = Promise.all([
+            ReportingService.getReportingGenerationStatus().then((resp) => this.#generationStatus.setValue(resp.data)),
+            GoalsService.getGoalsMain().then((resp) => this.#mainGoals.setValue(resp.data.reduce((map, goal) => {
+                map[goal.id] = goal;
+                return map;
+            }, {}))),
+        ]);
+        this.#scaffoldInit = Promise.all([
+            this.#projectItemRepository
+                .requestItems([])
+                .then((projects) => this.#projects.setValue(projects.data ?? [])),
+            GoalsService.getGoalsAll().then((goals) => this.#goals.setValue(goals.data ?? [])),
+        ]);
+    }
+    setActiveView(path) {
+        this.#activeView.setValue(path);
+    }
+    getTestVariants() {
+        return this.getData()?.test.variants ?? [];
+    }
+    async load(id) {
+        await this.#init;
+        return await super.load(id);
+    }
+    async createScaffold() {
+        await this.#scaffoldInit;
+        const modalContext = await this.getContext(UMB_MODAL_CONTEXT);
+        // preset varies based on the section:
+        // content => include umbracoPageVariants
+        // engage => include projectid
+        const data = await super.createScaffold({
+            parent: {
+                unique: "",
+                entityType: ENGAGE_AB_TESTING_TEST_ENTITY_TYPE,
+            },
+            preset: {
+                test: {
+                    umbracoPageVariants: modalContext?.data.umbracoPageVariants ?? [],
+                    projectId: modalContext?.data.projectId ?? 0,
+                },
+            },
+        });
+        return data;
+    }
+    async delete() {
+        const unique = this.getUnique();
+        if (!unique)
+            return;
+        await super.delete(unique);
+        await this.#hostWorkspaceContext?.reload();
+    }
+    async updateTest(test, save = false) {
+        const current = this.getData();
+        if (!current?.test)
+            return;
+        this._data.updateCurrent({
+            ...current,
+            test: { ...current.test, ...test },
+        });
+        if (!save)
+            return;
+        await this.requestSave();
+    }
+    async disableVariant(id) {
+        const { data, error } = await tryExecute(this, ABTestVariantService.postAbTestVariantDisable({
+            query: { variantId: id },
+        }));
+        if (!data || error) {
+            return;
+        }
+        const test = this.getData();
+        if (!test)
+            return;
+        await this.updateTest({
+            variants: partialUpdateFrozenArray(test.variants ?? [], data, (x) => x.id === data.id),
+        });
+    }
+    async requestSave(next = false) {
+        let test = this.getData()?.test;
+        if (!test)
+            return;
+        this.update({
+            test: {
+                ...test,
+                goal: this.#goals.getValue().find((g) => g.id === test.goalId) ?? null,
+            },
+        });
+        const isNew = this.getIsNew();
+        await super.requestSave(next);
+        if (isNew) {
+            this.setIsNew(!next);
+        }
+        await this.#hostWorkspaceContext?.reload();
+    }
+}
+export { UeAbTestingTestWorkspaceContext as api };

package/dist/ab-testing/test/workspace/actions/ab-test-action-base.d.ts

@@ -0,0 +1,13 @@
+import { UmbWorkspaceActionBase, type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { UMB_MODAL_MANAGER_CONTEXT } from "@umbraco-cms/backoffice/modal";
+import { ENGAGE_AB_TESTING_TEST_WORKSPACE_CONTEXT } from "../ab-testing-test-workspace-context.token.js";
+import type { AbTestDtoModel } from "../../../../generated/index.js";
+export declare abstract class UeAbTestingTestActionBase extends UmbWorkspaceActionBase<UmbSubmittableWorkspaceContext> {
+    workspaceContext?: typeof ENGAGE_AB_TESTING_TEST_WORKSPACE_CONTEXT.TYPE;
+    modalContext?: typeof UMB_MODAL_MANAGER_CONTEXT.TYPE;
+    test?: AbTestDtoModel;
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    closeModal(): Promise<void>;
+    navigateTo(pathname: string): void;
+}

package/dist/ab-testing/test/workspace/actions/ab-test-action-base.js

@@ -0,0 +1,43 @@
+import { UmbWorkspaceActionBase, } from "@umbraco-cms/backoffice/workspace";
+import { UMB_MODAL_MANAGER_CONTEXT } from "@umbraco-cms/backoffice/modal";
+import { firstValueFrom } from "@umbraco-cms/backoffice/external/rxjs";
+import { ENGAGE_AB_TESTING_TEST_WORKSPACE_CONTEXT } from "../ab-testing-test-workspace-context.token.js";
+import { UMB_ACTION_EVENT_CONTEXT } from "@umbraco-cms/backoffice/action";
+import { UeEntityActionEvent } from "../../../../core/index.js";
+export class UeAbTestingTestActionBase extends UmbWorkspaceActionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(ENGAGE_AB_TESTING_TEST_WORKSPACE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.workspaceContext = context;
+            this.observe(context.test, (test) => (this.test = test));
+        });
+        this.consumeContext(UMB_MODAL_MANAGER_CONTEXT, (context) => {
+            this.modalContext = context;
+        });
+    }
+    async closeModal() {
+        if (!this.modalContext)
+            return;
+        const modals = await firstValueFrom(this.modalContext.modals);
+        const modal = modals[modals.length - 1];
+        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() ?? "",
+        }));
+        modal.submit();
+    }
+    navigateTo(pathname) {
+        let current = location.pathname;
+        // Trim `/view/<slug>` (with optional trailing slash) from the end of the current pathname
+        const trimViewSlug = (p) => p.replace(/\/view\/[^/]+\/?$/, "");
+        const base = trimViewSlug(current).replace(/\/$/, "");
+        const target = `${base}/view/${pathname}`;
+        // navigate
+        history.pushState(null, "", target);
+    }
+}

package/dist/ab-testing/test/workspace/actions/delete-test-action.d.ts

@@ -0,0 +1,8 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export declare class UeAbTestingTestDeleteTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    execute(): Promise<void>;
+}
+export { UeAbTestingTestDeleteTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/delete-test-action.js

@@ -0,0 +1,19 @@
+import { ENGAGE_AB_TESTING_DELETE_TEST_MODAL_ALIAS, } from "../../modal/index.js";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export class UeAbTestingTestDeleteTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host, args) {
+        super(host, args);
+    }
+    async execute() {
+        if (!this.modalContext)
+            return;
+        const modalHandler = this.modalContext.open(this, ENGAGE_AB_TESTING_DELETE_TEST_MODAL_ALIAS);
+        await modalHandler.onSubmit().catch(() => { });
+        const { confirmed } = modalHandler.getValue();
+        if (!confirmed)
+            return;
+        await this.workspaceContext?.delete();
+        this.closeModal();
+    }
+}
+export { UeAbTestingTestDeleteTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/end-test-action.d.ts

@@ -0,0 +1,9 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export declare class UeAbTestingTestEndTestWorkspaceAction extends UeAbTestingTestActionBase {
+    #private;
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    execute(): Promise<void>;
+}
+export { UeAbTestingTestEndTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/end-test-action.js

@@ -0,0 +1,33 @@
+import { ENGAGE_AB_TESTING_END_TEST_MODAL_ALIAS, ENGAGE_AB_TESTING_TEST_SELECT_WINNER_MODAL_ALIAS, } from "../../modal/index.js";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export class UeAbTestingTestEndTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host, args) {
+        super(host, args);
+    }
+    async execute() {
+        if (!this.modalContext)
+            return;
+        const modalHandler = this.modalContext.open(this._host, ENGAGE_AB_TESTING_END_TEST_MODAL_ALIAS);
+        await modalHandler.onSubmit().catch(() => { });
+        const { complete } = modalHandler.getValue();
+        await this.workspaceContext?.updateTest({ status: "Stopped" }, true);
+        if (!complete)
+            return;
+        await this.#selectWinner();
+    }
+    async #selectWinner() {
+        if (!this.modalContext)
+            return;
+        const modalHandler = this.modalContext.open(this, ENGAGE_AB_TESTING_TEST_SELECT_WINNER_MODAL_ALIAS);
+        await modalHandler.onSubmit().catch(() => { });
+        const value = modalHandler.getValue();
+        if (!value)
+            return;
+        await this.workspaceContext?.updateTest({
+            winner: value.selection,
+            isCompleted: true,
+            status: "Completed",
+        }, true);
+    }
+}
+export { UeAbTestingTestEndTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/index.d.ts

@@ -0,0 +1,8 @@
+export { UeAbTestingTestSelectWinnerWorkspaceAction } from "./select-winner-action.js";
+export { UeAbTestingTestEndTestWorkspaceAction } from "./end-test-action.js";
+export { UeAbTestingTestDeleteTestWorkspaceAction } from "./delete-test-action.js";
+export { UeAbTestingTestUnscheduleTestWorkspaceAction } from "./unschedule-test-action.js";
+export { UeAbTestingTestScheduleTestWorkspaceAction } from "./schedule-test-action.js";
+export { UeAbTestingTestStartTestWorkspaceAction } from "./start-test-action.js";
+export { UeAbTestingTestSaveTestWorkspaceAction } from "./save-test-action.js";
+export { UeAbTestingTestSubmitTestWorkspaceAction } from "./submit-test-action.js";

package/dist/ab-testing/test/workspace/actions/index.js

@@ -0,0 +1,8 @@
+export { UeAbTestingTestSelectWinnerWorkspaceAction } from "./select-winner-action.js";
+export { UeAbTestingTestEndTestWorkspaceAction } from "./end-test-action.js";
+export { UeAbTestingTestDeleteTestWorkspaceAction } from "./delete-test-action.js";
+export { UeAbTestingTestUnscheduleTestWorkspaceAction } from "./unschedule-test-action.js";
+export { UeAbTestingTestScheduleTestWorkspaceAction } from "./schedule-test-action.js";
+export { UeAbTestingTestStartTestWorkspaceAction } from "./start-test-action.js";
+export { UeAbTestingTestSaveTestWorkspaceAction } from "./save-test-action.js";
+export { UeAbTestingTestSubmitTestWorkspaceAction } from "./submit-test-action.js";

package/dist/ab-testing/test/workspace/actions/manifests.d.ts

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

package/dist/ab-testing/test/workspace/actions/manifests.js

@@ -0,0 +1,111 @@
+import { UMB_WORKSPACE_CONDITION_ALIAS } from "@umbraco-cms/backoffice/workspace";
+import { ENGAGE_AB_TESTING_TEST_WORKSPACE_ALIAS } from "../../constants.js";
+import { ENGAGE_AB_TESTING_TEST_ENTITY_ACTION_VISIBILITY_CONDITION } from "../conditions/constants.js";
+import { UeAbTestingTestDeleteTestWorkspaceAction } from "./delete-test-action.js";
+import { UeAbTestingTestEndTestWorkspaceAction } from "./end-test-action.js";
+import { UeAbTestingTestScheduleTestWorkspaceAction } from "./schedule-test-action.js";
+import { UeAbTestingTestSelectWinnerWorkspaceAction } from "./select-winner-action.js";
+import { UeAbTestingTestStartTestWorkspaceAction } from "./start-test-action.js";
+import { UeAbTestingTestUnscheduleTestWorkspaceAction } from "./unschedule-test-action.js";
+import { UeAbTestingTestSaveTestWorkspaceAction, UeAbTestingTestSubmitTestWorkspaceAction, } from "../index.js";
+import { ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS, ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS, } from "../../../../core/index.js";
+const actions = [
+    {
+        weight: 10,
+        alias: "Engage.WorkspaceAction.AbTestingTest.SelectWinner",
+        api: UeAbTestingTestSelectWinnerWorkspaceAction,
+        key: "Select Winner",
+        forStatus: ["Stopped"],
+    },
+    {
+        weight: 20,
+        alias: "Engage.WorkspaceAction.AbTestingTest.EndTest",
+        api: UeAbTestingTestEndTestWorkspaceAction,
+        key: "End Test",
+        forStatus: ["Running"],
+    },
+    {
+        weight: 50,
+        alias: "Engage.WorkspaceAction.AbTestingTest.DeleteTest",
+        api: UeAbTestingTestDeleteTestWorkspaceAction,
+        key: "Delete Test",
+        color: "danger",
+        forStatus: ["Draft", "Scheduled"],
+        forView: ["edit", "scoring"],
+        notNew: true,
+    },
+    {
+        weight: 40,
+        alias: "Engage.WorkspaceAction.AbTestingTest.UnscheduleTest",
+        api: UeAbTestingTestUnscheduleTestWorkspaceAction,
+        key: "Unschedule Test",
+        forStatus: ["Scheduled"],
+        forView: ["scoring"],
+    },
+    {
+        weight: 40,
+        alias: "Engage.WorkspaceAction.AbTestingTest.ScheduleTest",
+        api: UeAbTestingTestScheduleTestWorkspaceAction,
+        key: "Schedule Test",
+        forStatus: ["Draft"],
+        forView: ["scoring"],
+    },
+    {
+        weight: 10,
+        alias: "Engage.WorkspaceAction.AbTestingTest.StartTest",
+        api: UeAbTestingTestStartTestWorkspaceAction,
+        key: "Start Test",
+        forStatus: ["Draft"],
+        forView: ["scoring"],
+    },
+    {
+        weight: 10,
+        alias: "Engage.WorkspaceAction.AbTestingTest.SaveTest",
+        api: UeAbTestingTestSaveTestWorkspaceAction,
+        key: "Save Test",
+        forStatus: ["Draft"],
+        forView: ["edit"],
+    },
+    {
+        weight: 10,
+        alias: "Engage.WorkspaceAction.AbTestingTest.SubmitTest",
+        api: UeAbTestingTestSubmitTestWorkspaceAction,
+        key: "Submit Test",
+        forStatus: ["Draft"],
+        forView: ["edit"],
+    },
+];
+export const manifests = actions.map((action) => {
+    const conditions = [
+        {
+            alias: UMB_WORKSPACE_CONDITION_ALIAS,
+            match: ENGAGE_AB_TESTING_TEST_WORKSPACE_ALIAS,
+        },
+        {
+            alias: ENGAGE_AB_TESTING_TEST_ENTITY_ACTION_VISIBILITY_CONDITION,
+            oneOf: action.forStatus,
+        },
+    ];
+    if (action.notNew) {
+        conditions.push({ alias: ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS });
+    }
+    if (action.forView) {
+        conditions.push({
+            alias: ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS,
+            oneOf: action.forView,
+        });
+    }
+    const manifest = {
+        ...action,
+        type: "workspaceAction",
+        kind: "default",
+        name: `Engage AB Testing Test ${action.key} Workspace Action`,
+        meta: {
+            look: "primary",
+            color: action.color ?? "positive",
+            label: `#engage_abTesting_button${action.key.replace(" ", "")}`,
+        },
+        conditions,
+    };
+    return manifest;
+});

package/dist/ab-testing/test/workspace/actions/save-test-action.d.ts

@@ -0,0 +1,8 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export declare class UeAbTestingTestSaveTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    execute(): Promise<void>;
+}
+export { UeAbTestingTestSaveTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/save-test-action.js

@@ -0,0 +1,10 @@
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export class UeAbTestingTestSaveTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host, args) {
+        super(host, args);
+    }
+    async execute() {
+        await this.workspaceContext?.requestSave();
+    }
+}
+export { UeAbTestingTestSaveTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/schedule-test-action.d.ts

@@ -0,0 +1,8 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export declare class UeAbTestingTestScheduleTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    execute(): Promise<void>;
+}
+export { UeAbTestingTestScheduleTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/schedule-test-action.js

@@ -0,0 +1,18 @@
+import { ENGAGE_AB_TESTING_SCHEDULE_TEST_MODAL_ALIAS, } from "../../modal/index.js";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export class UeAbTestingTestScheduleTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host, args) {
+        super(host, args);
+    }
+    async execute() {
+        if (!this.modalContext || !this.test)
+            return;
+        const modalHandler = this.modalContext.open(this, ENGAGE_AB_TESTING_SCHEDULE_TEST_MODAL_ALIAS);
+        await modalHandler?.onSubmit().catch(() => { });
+        const { date } = modalHandler.getValue();
+        if (!date)
+            return;
+        await this.workspaceContext?.updateTest({ startTime: date }, true);
+    }
+}
+export { UeAbTestingTestScheduleTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/select-winner-action.d.ts

@@ -0,0 +1,8 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export declare class UeAbTestingTestSelectWinnerWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    execute(): Promise<void>;
+}
+export { UeAbTestingTestSelectWinnerWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/select-winner-action.js

@@ -0,0 +1,22 @@
+import { ENGAGE_AB_TESTING_TEST_SELECT_WINNER_MODAL_ALIAS, } from "../../modal/index.js";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export class UeAbTestingTestSelectWinnerWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host, args) {
+        super(host, args);
+    }
+    async execute() {
+        if (!this.modalContext)
+            return;
+        const modalHandler = this.modalContext.open(this, ENGAGE_AB_TESTING_TEST_SELECT_WINNER_MODAL_ALIAS);
+        await modalHandler.onSubmit().catch(() => { });
+        const value = modalHandler.getValue();
+        if (!value)
+            return;
+        await this.workspaceContext?.updateTest({
+            winner: value.selection,
+            isCompleted: true,
+            status: "Completed",
+        }, true);
+    }
+}
+export { UeAbTestingTestSelectWinnerWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/start-test-action.d.ts

@@ -0,0 +1,8 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export declare class UeAbTestingTestStartTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    execute(): Promise<void>;
+}
+export { UeAbTestingTestStartTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/start-test-action.js

@@ -0,0 +1,11 @@
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+import { DateUtils } from "../../../../core/index.js";
+export class UeAbTestingTestStartTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host, args) {
+        super(host, args);
+    }
+    async execute() {
+        await this.workspaceContext?.updateTest({ startTime: DateUtils.format(new Date()) }, true);
+    }
+}
+export { UeAbTestingTestStartTestWorkspaceAction as api };

package/dist/ab-testing/test/workspace/actions/submit-test-action.d.ts

@@ -0,0 +1,8 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type UmbSubmittableWorkspaceContext, type UmbWorkspaceActionArgs } from "@umbraco-cms/backoffice/workspace";
+import { UeAbTestingTestActionBase } from "./ab-test-action-base.js";
+export declare class UeAbTestingTestSubmitTestWorkspaceAction extends UeAbTestingTestActionBase {
+    constructor(host: UmbControllerHost, args: UmbWorkspaceActionArgs<UmbSubmittableWorkspaceContext>);
+    execute(): Promise<void>;
+}
+export { UeAbTestingTestSubmitTestWorkspaceAction as api };