@umbraco-engage/backoffice 17.0.0-rc1

package/dist/personalization/content-scoring/workspace/content-scoring-workspace-editor.element.js

@@ -0,0 +1,204 @@
+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 { ENGAGE_CONTENT_SCORING_WORKSPACE_CONTEXT } from "./content-scoring-workspace-context.token.js";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { css, customElement, html, state, when, } from "@umbraco-cms/backoffice/external/lit";
+const elementName = "ue-content-scoring-workspace-editor";
+let UeContentScoringWorkspaceEditorElement = class UeContentScoringWorkspaceEditorElement extends UmbLitElement {
+    #workspaceContext;
+    constructor() {
+        super();
+        this.defaultUpperScoreLimit = 10;
+        this._buttonState = {
+            None: undefined,
+            Persona: undefined,
+            Journey: undefined,
+        };
+        this.consumeContext(ENGAGE_CONTENT_SCORING_WORKSPACE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.#workspaceContext = context;
+            this.observe(this.#workspaceContext.data, (data) => {
+                if (data === undefined)
+                    return;
+                this._data = data;
+            });
+            this.observe(this.#workspaceContext.personas, (personas) => {
+                this._personas = personas;
+            });
+            this.observe(this.#workspaceContext.journeys, (journeys) => {
+                this._journeys = journeys;
+            });
+        });
+    }
+    #renderJourneys() {
+        if (!this._journeys?.length)
+            return;
+        return html `<ue-divider
+        .text=${this.localize.term("engage_availableCustomerJourneys")}
+      ></ue-divider>
+      ${this._journeys.map((p) => this.#renderGroup(p))}`;
+    }
+    #renderPersonas() {
+        if (!this._personas?.length)
+            return;
+        return html `<ue-divider
+        .text=${this.localize.term("engage_availablePersonaGroups")}
+      ></ue-divider>
+      ${this._personas.map((p) => this.#renderGroup(p))}`;
+    }
+    async #onValueChange(e, item, group) {
+        const value = Number(e.target.value);
+        //Enforce the upper score limit
+        if (group.upperScoreLimit && value > group.upperScoreLimit) {
+            e.target.value = group.upperScoreLimit.toString();
+        }
+        // Enforce non-negative values
+        if (value < 0) {
+            e.target.value = "0";
+        }
+        await this.#workspaceContext?.setItem(e.target.value, item);
+    }
+    #getValue(item) {
+        const score = this._data?.items.find((x) => x.entityId === item.id && x.type === item.entityType)?.score;
+        return score ?? 0;
+    }
+    async #onSave(entityType) {
+        this._buttonState = { ...this._buttonState, [entityType]: "waiting" };
+        try {
+            await this.#workspaceContext?.requestSave();
+            this._buttonState = { ...this._buttonState, [entityType]: "success" };
+        }
+        catch {
+            this._buttonState = { ...this._buttonState, [entityType]: "failed" };
+        }
+    }
+    async #onSaveAll() {
+        // Save all changes at once
+        this._buttonState = {
+            ...this._buttonState,
+            None: "waiting",
+            Persona: "waiting",
+            Journey: "waiting",
+        };
+        try {
+            await this.#workspaceContext?.requestSave();
+            this._buttonState = {
+                ...this._buttonState,
+                None: "success",
+                Persona: "success",
+                Journey: "success",
+            };
+        }
+        catch {
+            this._buttonState = {
+                ...this._buttonState,
+                None: "failed",
+                Persona: "failed",
+                Journey: "failed",
+            };
+        }
+    }
+    #renderGroup(group) {
+        //Hide groups without items
+        if (!group.items?.length)
+            return;
+        return html `<uui-box .headline=${group.title ?? ""}>
+      ${when(group.upperScoreLimit !== this.defaultUpperScoreLimit, () => html ` <div slot="header-actions">
+            ${this.localize.term("engage_scoreFromTo", group.upperScoreLimit)}
+          </div>`)}
+      ${group.items.map((item) => html `<ue-group-box
+            style=${`--engage-bar-color: ${item.color?.value}`}
+            .name=${item.title}
+            .description=${item.description}
+            .iconUrl=${item.iconUrl}
+          >
+            ${group.upperScoreLimit && group.upperScoreLimit > 10
+            ? html `<uui-input
+                  type="number"
+                  max=${group.upperScoreLimit}
+                  min="0"
+                  @change=${(e) => this.#onValueChange(e, item, group)}
+                  .value=${this.#getValue(item).toString()}
+                ></uui-input>`
+            : html `<umb-input-slider
+                  .max=${group.upperScoreLimit ?? 10}
+                  @change=${(e) => this.#onValueChange(e, item, group)}
+                  .valueLow=${this.#getValue(item)}
+                ></umb-input-slider>`}
+          </ue-group-box>`)}
+    </uui-box>`;
+    }
+    render() {
+        if (!this._data)
+            return;
+        const hasAnyGroups = (this._personas?.some((p) => p.items?.length > 0) ||
+            this._journeys?.some((j) => j.items?.length > 0));
+        return html `
+      ${this.#renderPersonas()}
+      ${this.#renderJourneys()}
+      ${hasAnyGroups
+            ? html `
+            <div class="workspace-footer">
+              <uui-button
+                look="primary"
+                color="positive"
+                @click=${this.#onSaveAll}
+                .state=${this._buttonState.None}
+                .label=${this.localize.term("engage_saveScoring")}
+              ></uui-button>
+            </div>
+          `
+            : ""}
+    `;
+    }
+    static { this.styles = css `
+    uui-box + uui-box {
+      margin-top: var(--uui-size-layout-1);
+    }
+
+    ue-group-box + ue-group-box {
+      margin-top: var(--uui-size-5);
+    }
+
+    umb-input-slider {
+      width: 100%;
+    }
+
+    ue-divider:first-child {
+      margin-top: 0;
+    }
+
+    .box-footer {
+      display: flex;
+      justify-content: flex-end;
+      margin-top: var(--uui-size-3);
+    }
+
+    .workspace-footer {
+      display: flex;
+      justify-content: flex-end;
+      margin-top: var(--uui-size-3);
+    }
+  `; }
+};
+__decorate([
+    state()
+], UeContentScoringWorkspaceEditorElement.prototype, "_personas", void 0);
+__decorate([
+    state()
+], UeContentScoringWorkspaceEditorElement.prototype, "_journeys", void 0);
+__decorate([
+    state()
+], UeContentScoringWorkspaceEditorElement.prototype, "_data", void 0);
+__decorate([
+    state()
+], UeContentScoringWorkspaceEditorElement.prototype, "_buttonState", void 0);
+UeContentScoringWorkspaceEditorElement = __decorate([
+    customElement(elementName)
+], UeContentScoringWorkspaceEditorElement);
+export { UeContentScoringWorkspaceEditorElement };

package/dist/personalization/content-scoring/workspace/content-scoring-workspace.context.d.ts

@@ -0,0 +1,17 @@
+import { type UeContentScoringDetailModel } from "../entities.js";
+import type { UeContentScoringDetailRepository } from "../repository/detail/index.js";
+import type { UePersonaGroupDetailModel, UeCustomerJourneyDetailModel, UeScoringGroupEntityItemUnionModel } from "../../entities.js";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { UeWorkspaceContextBase } from "../../../core/index.js";
+export declare class UeContentScoringWorkspaceContext extends UeWorkspaceContextBase<UeContentScoringDetailModel, UeContentScoringDetailRepository> {
+    #private;
+    readonly IS_CONTENT_SCORING_WORKSPACE_CONTEXT = true;
+    items: import("rxjs").Observable<import("../entities.js").UeContentScore[] | undefined>;
+    personas: import("rxjs").Observable<UePersonaGroupDetailModel[]>;
+    journeys: import("rxjs").Observable<UeCustomerJourneyDetailModel[]>;
+    constructor(host: UmbControllerHost, hostUnique: string);
+    hostConnected(): Promise<import("@umbraco-cms/backoffice/repository").UmbRepositoryResponse<UeContentScoringDetailModel> | import("@umbraco-cms/backoffice/repository").UmbRepositoryResponseWithAsObservable<UeContentScoringDetailModel, UeContentScoringDetailModel>>;
+    setItem(value: string, item: UeScoringGroupEntityItemUnionModel): Promise<void>;
+    requestSave(): Promise<void>;
+    destroy(): void;
+}

package/dist/personalization/content-scoring/workspace/content-scoring-workspace.context.js

@@ -0,0 +1,77 @@
+import { ENGAGE_CONTENT_SCORE_ENTITY_TYPE, ENGAGE_CONTENT_SCORE_WORKSPACE_ALIAS, } from "../constants.js";
+import { ENGAGE_CONTENT_SCORING_DETAIL_REPOSITORY_ALIAS } from "../repository/detail/constants.js";
+import { UmbId } from "@umbraco-cms/backoffice/id";
+import { appendToFrozenArray, UmbArrayState, } from "@umbraco-cms/backoffice/observable-api";
+import { UeCustomerJourneyDetailRepository } from "../../journeys/index.js";
+import { UePersonaGroupDetailRepository, ENGAGE_PERSONA_ENTITY_TYPE, } from "../../personas/index.js";
+import { UeWorkspaceContextBase } from "../../../core/index.js";
+export class UeContentScoringWorkspaceContext extends UeWorkspaceContextBase {
+    #personaRepository;
+    #journeyRepository;
+    #init;
+    #hostUnique;
+    #personas;
+    #journeys;
+    constructor(host, hostUnique) {
+        super(host, {
+            workspaceAlias: ENGAGE_CONTENT_SCORE_WORKSPACE_ALIAS,
+            entityType: ENGAGE_CONTENT_SCORE_ENTITY_TYPE,
+            detailRepositoryAlias: ENGAGE_CONTENT_SCORING_DETAIL_REPOSITORY_ALIAS,
+        });
+        this.IS_CONTENT_SCORING_WORKSPACE_CONTEXT = true;
+        this.#personaRepository = new UePersonaGroupDetailRepository(this);
+        this.#journeyRepository = new UeCustomerJourneyDetailRepository(this);
+        this.items = this._data.createObservablePartOfCurrent((x) => x?.items);
+        this.#personas = new UmbArrayState([], (x) => x.unique);
+        this.personas = this.#personas.asObservable();
+        this.#journeys = new UmbArrayState([], (x) => x.unique);
+        this.journeys = this.#journeys.asObservable();
+        this.#hostUnique = hostUnique;
+        this.#init = Promise.all([
+            this.#personaRepository
+                .requestAll()
+                .then((resp) => this.#personas.setValue(resp.data ?? [])),
+            this.#journeyRepository
+                .requestAll()
+                .then((resp) => this.#journeys.setValue(resp.data ?? [])),
+        ]);
+    }
+    async hostConnected() {
+        super.hostConnected();
+        await this.#init;
+        return await super.load(this.#hostUnique);
+    }
+    async setItem(value, item) {
+        const typeMatch = item.entityType === ENGAGE_PERSONA_ENTITY_TYPE ? "Persona" : "Journey";
+        const items = this._data.getCurrent()?.items ?? [];
+        const existing = items.find((x) => x.entityId === item.id && x.type === typeMatch);
+        if (existing) {
+            this.update({
+                items: appendToFrozenArray(items, { ...existing, ...{ score: Number(value) } }, (x) => x.unique === existing.unique),
+            });
+        }
+        else {
+            // unique is not persisted, only used for the getUniqueMethod matching
+            this.update({
+                items: appendToFrozenArray(items, {
+                    score: Number(value),
+                    entityId: item.id,
+                    entityUnique: item.unique,
+                    documentUnique: this.#hostUnique,
+                    type: typeMatch,
+                    id: 0,
+                    unique: UmbId.new(),
+                }),
+            });
+        }
+    }
+    async requestSave() {
+        this._data.updateCurrent({ unique: this.#hostUnique });
+        super.requestSave();
+    }
+    destroy() {
+        this.#personaRepository.destroy();
+        this.#journeyRepository.destroy();
+        super.destroy();
+    }
+}

package/dist/personalization/content-scoring/workspace/index.d.ts

@@ -0,0 +1,3 @@
+export { UeContentScoringWorkspaceContext } from "./content-scoring-workspace.context.js";
+export * from "./content-scoring-workspace-context.token.js";
+export * from "./content-scoring-workspace-editor.element.js";

package/dist/personalization/content-scoring/workspace/index.js

@@ -0,0 +1,3 @@
+export { UeContentScoringWorkspaceContext } from "./content-scoring-workspace.context.js";
+export * from "./content-scoring-workspace-context.token.js";
+export * from "./content-scoring-workspace-editor.element.js";

package/dist/personalization/context/grouped-items-workspace-context.interface.d.ts

@@ -0,0 +1,24 @@
+import type { Observable } from "@umbraco-cms/backoffice/observable-api";
+import type { UmbSubmittableWorkspaceContext } from "@umbraco-cms/backoffice/workspace";
+import type { UePropertyConfigData } from "../../core/index.js";
+export interface UeGroupedItemWorkspaceContext<EntityModel, EntityItemModel> extends UmbSubmittableWorkspaceContext {
+    data: Observable<Array<EntityModel> | undefined>;
+    current: Observable<EntityModel | undefined>;
+    properties: Observable<UePropertyConfigData<EntityModel> | undefined>;
+    advancedProperties: Observable<UePropertyConfigData<EntityModel> | undefined>;
+    editHeadline: Observable<string | undefined>;
+    load: (unique: string) => Promise<void>;
+    createItem: () => EntityItemModel;
+    getGroup: (unique: string) => EntityModel | undefined;
+    createGroup: () => Promise<EntityModel | undefined>;
+    getCurrent: () => EntityModel | undefined;
+    setCurrent: (data: EntityModel) => void;
+    setItem: (data: EntityItemModel, position?: number) => void;
+    setPath: (unique: string) => void;
+    deleteItem: (unique: string) => Promise<void>;
+    deleteGroup: (unique: string) => Promise<void>;
+    sortItems: (sortOrder: Array<string>) => void;
+    getProperties: () => UePropertyConfigData<EntityModel> | undefined;
+    getAdvancedProperties: () => UePropertyConfigData<EntityModel> | undefined;
+    getEditHeadline: () => string | undefined;
+}

package/dist/personalization/context/grouped-items-workspace-context.interface.js

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

package/dist/personalization/context/grouped-items-workspace-context.token.d.ts

@@ -0,0 +1,4 @@
+import type { UeGroupedItemWorkspaceContext } from './grouped-items-workspace-context.interface.js';
+import { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+import type { UmbSubmittableWorkspaceContext } from "@umbraco-cms/backoffice/workspace";
+export declare const ENGAGE_GROUPED_ITEM_WORKSPACE_CONTEXT: UmbContextToken<UmbSubmittableWorkspaceContext, UeGroupedItemWorkspaceContext<any, any>>;

package/dist/personalization/context/grouped-items-workspace-context.token.js

@@ -0,0 +1,3 @@
+import { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+export const ENGAGE_GROUPED_ITEM_WORKSPACE_CONTEXT = new UmbContextToken("UmbWorkspaceContext", undefined, (context) => context
+    .IS_GROUPED_ITEMS_WORKSPACE_CONTEXT);

package/dist/personalization/context/grouped-items-workspace.context.d.ts

@@ -0,0 +1,45 @@
+import type { UeGroupedItemWorkspaceContext } from "./grouped-items-workspace-context.interface.js";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { UmbSubmittableWorkspaceContextBase } from "@umbraco-cms/backoffice/workspace";
+import type { UeDetailRepositoryConstructor, UeGroupedItemDetailModel, UeGroupedItemListModel, UePropertyConfigData } from "../../core/index.js";
+export declare class UeGroupedItemsWorkspaceContextBase<EntityModel extends UeGroupedItemDetailModel, EntityItemModel extends UeGroupedItemListModel> extends UmbSubmittableWorkspaceContextBase<Array<EntityModel>> implements UeGroupedItemWorkspaceContext<EntityModel, EntityItemModel> {
+    #private;
+    readonly IS_GROUPED_ITEMS_WORKSPACE_CONTEXT = true;
+    data: import("rxjs").Observable<EntityModel[]>;
+    current: import("rxjs").Observable<EntityModel | undefined>;
+    properties: import("rxjs").Observable<UePropertyConfigData<EntityModel> | undefined>;
+    advancedProperties: import("rxjs").Observable<UePropertyConfigData<EntityModel> | undefined>;
+    editHeadline: import("rxjs").Observable<string | undefined>;
+    init: Promise<unknown>;
+    readonly path: string;
+    readonly entityType: string;
+    constructor(host: UmbControllerHost, args: {
+        workspaceAlias: string;
+        entityType: string;
+        detailRepositoryConstructor: UeDetailRepositoryConstructor<EntityModel>;
+        properties: UePropertyConfigData<EntityModel>;
+        advancedProperties?: UePropertyConfigData<EntityModel>;
+        editHeadline?: string;
+    });
+    readonly unique: import("rxjs").Observable<string>;
+    getUnique(): string | null | undefined;
+    getEntityType(): string;
+    getData(): Array<EntityModel> | undefined;
+    getCurrent(): EntityModel | undefined;
+    getEditHeadline(): string | undefined;
+    setPath(unique?: string): void;
+    load(unique: string): Promise<void>;
+    createGroup(): Promise<EntityModel | undefined>;
+    createItem(): EntityItemModel;
+    setCurrent(data: EntityModel): void;
+    setItem(data: EntityItemModel, position?: number): void;
+    submit(): Promise<void>;
+    requestSubmit(): Promise<void>;
+    getProperties(): UePropertyConfigData<EntityModel> | undefined;
+    getAdvancedProperties(): UePropertyConfigData<EntityModel> | undefined;
+    getGroup(unique: string): EntityModel | undefined;
+    deleteGroup(unique: string): Promise<void>;
+    deleteItem(unique: string): Promise<void>;
+    sortItems(sortOrder: Array<string>): void;
+    destroy(): void;
+}

package/dist/personalization/context/grouped-items-workspace.context.js

@@ -0,0 +1,152 @@
+import { UmbId } from "@umbraco-cms/backoffice/id";
+import { appendToFrozenArray, UmbArrayState, UmbObjectState, UmbStringState, } from "@umbraco-cms/backoffice/observable-api";
+import { UmbValidationController } from "@umbraco-cms/backoffice/validation";
+import { UmbSubmittableWorkspaceContextBase } from "@umbraco-cms/backoffice/workspace";
+export class UeGroupedItemsWorkspaceContextBase extends UmbSubmittableWorkspaceContextBase {
+    #detailRepository;
+    #data;
+    #current;
+    #properties;
+    #advancedProperties;
+    #editHeadline;
+    constructor(host, args) {
+        super(host, args.workspaceAlias);
+        this.IS_GROUPED_ITEMS_WORKSPACE_CONTEXT = true;
+        this.#data = new UmbArrayState([], (x) => x.unique);
+        this.data = this.#data.asObservable();
+        this.#current = new UmbObjectState(undefined);
+        this.current = this.#current.asObservable();
+        this.#properties = new UmbObjectState(undefined);
+        this.properties = this.#properties.asObservable();
+        this.#advancedProperties = new UmbObjectState(undefined);
+        this.advancedProperties = this.#advancedProperties.asObservable();
+        this.#editHeadline = new UmbStringState(undefined);
+        this.editHeadline = this.#editHeadline.asObservable();
+        this.unique = this.#data.asObservablePart(() => "");
+        this.#detailRepository = new args.detailRepositoryConstructor(host);
+        this.entityType = args.entityType;
+        this.path = window.location.pathname;
+        this.#properties.setValue(args.properties);
+        this.#advancedProperties.setValue(args.advancedProperties);
+        this.#editHeadline.setValue(args.editHeadline);
+        this.addValidationContext(new UmbValidationController(host));
+        this.init = this.#detailRepository.requestAll().then((resp) => {
+            this.#data.setValue(resp.data ?? []);
+            if (!this.path.includes("/edit/")) {
+                this.setPath(resp.data?.at(0)?.unique);
+            }
+        });
+    }
+    getUnique() {
+        return "";
+    }
+    getEntityType() {
+        return this.entityType;
+    }
+    getData() {
+        return this.#data.getValue();
+    }
+    getCurrent() {
+        return this.#current.getValue();
+    }
+    getEditHeadline() {
+        return this.#editHeadline.getValue();
+    }
+    setPath(unique) {
+        if (!unique)
+            return;
+        let path = this.path?.split("/edit")[0];
+        path += `/edit/${unique}`;
+        window.history.pushState(null, "", path);
+    }
+    async load(unique) {
+        await this.init;
+        this.#current.setValue(this.getData()?.find((x) => x.unique === unique));
+    }
+    async createGroup() {
+        await this.init;
+        const { data } = await this.#detailRepository.createScaffold();
+        if (!data)
+            return;
+        return data;
+    }
+    createItem() {
+        return {
+            color: { label: "", value: "" },
+            unique: UmbId.new(),
+            entityType: this.entityType,
+        };
+    }
+    setCurrent(data) {
+        this.#current.setValue(data);
+    }
+    setItem(data, position) {
+        const items = appendToFrozenArray(this.getCurrent()?.items ?? [], data, (x) => x.unique === data.unique);
+        // if position is provided, sort the new entry to that position
+        // this is done after appending to ensure we have an unfrozen array to manipulate
+        if (position !== undefined) {
+            items.splice(position, 0, items.pop());
+        }
+        this.#current.update({
+            items,
+        });
+    }
+    submit() {
+        return this.#handleSubmit();
+    }
+    requestSubmit() {
+        return this.#handleSubmit();
+    }
+    async #handleSubmit() {
+        const model = this.getCurrent();
+        if (!model)
+            return;
+        const { data, error } = await this.#detailRepository.save(model);
+        if (!data || error)
+            return;
+        await this.#refresh(data.unique);
+    }
+    async #refresh(unique) {
+        const { data } = await this.#detailRepository.requestAll();
+        this.#data.setValue(data ?? []);
+        unique = unique ?? this.getData()?.at(0)?.unique;
+        if (!unique)
+            return;
+        this.setPath(unique);
+        await this.load(unique);
+    }
+    getProperties() {
+        return this.#properties.getValue();
+    }
+    getAdvancedProperties() {
+        return this.#advancedProperties.getValue();
+    }
+    getGroup(unique) {
+        return this.getData()?.find((x) => x.unique === unique);
+    }
+    async deleteGroup(unique) {
+        if (!unique)
+            return;
+        await this.#detailRepository.delete(unique);
+        await this.#refresh();
+    }
+    async deleteItem(unique) {
+        this.#current.update({
+            items: [
+                ...(this.getCurrent()?.items.filter((x) => x.unique !== unique) ?? []),
+            ],
+        });
+        await this.#handleSubmit();
+    }
+    sortItems(sortOrder) {
+        const items = [...(this.getCurrent()?.items ?? [])];
+        const sorted = sortOrder.map((x) => items.find((y) => y.unique === x));
+        this.#current.update({
+            items: sorted,
+        });
+    }
+    destroy() {
+        this.#detailRepository.destroy();
+        super.destroy();
+    }
+}

package/dist/personalization/context/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./grouped-items-workspace.context.js";
+export * from "./personalization-editor-view-base.context.js";
+export * from "./grouped-items-workspace-context.interface.js";
+export * from "./grouped-items-workspace-context.token.js";

package/dist/personalization/context/index.js

@@ -0,0 +1,4 @@
+export * from "./grouped-items-workspace.context.js";
+export * from "./personalization-editor-view-base.context.js";
+export * from "./grouped-items-workspace-context.interface.js";
+export * from "./grouped-items-workspace-context.token.js";

package/dist/personalization/context/personalization-editor-view-base.context.d.ts

@@ -0,0 +1,25 @@
+import { UeAppliedPersonalizationDetailRepository, UeAppliedPersonalizationItemRepository } from "../applied-personalization/index.js";
+import type { UeAppliedPersonalizationDetailModel } from "../applied-personalization/entities.js";
+import { UeSegmentsDetailRepository } from "../segments/repository/detail/index.js";
+import { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { UmbArrayState } from "@umbraco-cms/backoffice/observable-api";
+import type { UeSegmentDetailModel } from "../segments/index.js";
+export declare class UePersonalizationEditorViewBaseContext extends UmbContextBase {
+    #private;
+    protected itemRepository: UeAppliedPersonalizationItemRepository;
+    protected detailRepository: UeAppliedPersonalizationDetailRepository;
+    protected segmentsRepository: UeSegmentsDetailRepository;
+    protected personalizations: UmbArrayState<UeAppliedPersonalizationDetailModel, unknown>;
+    personalizations$: import("rxjs").Observable<UeAppliedPersonalizationDetailModel[]>;
+    protected segments: UmbArrayState<UeSegmentDetailModel, unknown>;
+    segments$: import("rxjs").Observable<UeSegmentDetailModel[]>;
+    constructor(host: UmbControllerHost, contextToken: string);
+    load(): Promise<void>;
+    delete(unique: string): Promise<void>;
+    requestItems(): Promise<void>;
+    preview(variant: UeAppliedPersonalizationDetailModel): Promise<void>;
+    getPersonalizationByUnique(unique: string): UeAppliedPersonalizationDetailModel | undefined;
+    getPersonalizationsForPage(): Promise<UeAppliedPersonalizationDetailModel[]>;
+    destroy(): void;
+}

package/dist/personalization/context/personalization-editor-view-base.context.js

@@ -0,0 +1,78 @@
+import { UeAppliedPersonalizationDetailRepository, UeAppliedPersonalizationItemRepository, } from "../applied-personalization/index.js";
+import { UeSegmentsDetailRepository } from "../segments/repository/detail/index.js";
+import { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import { UmbArrayState } from "@umbraco-cms/backoffice/observable-api";
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/document";
+import { UMB_PROPERTY_DATASET_CONTEXT } from "@umbraco-cms/backoffice/property";
+import { UeVariantPreviewController } from "../../core/index.js";
+export class UePersonalizationEditorViewBaseContext extends UmbContextBase {
+    #init;
+    #preview;
+    constructor(host, contextToken) {
+        super(host, contextToken);
+        this.itemRepository = new UeAppliedPersonalizationItemRepository(this);
+        this.detailRepository = new UeAppliedPersonalizationDetailRepository(this);
+        this.segmentsRepository = new UeSegmentsDetailRepository(this);
+        this.personalizations = new UmbArrayState([], (x) => x.unique);
+        this.personalizations$ = this.personalizations.asObservable();
+        this.segments = new UmbArrayState([], (x) => x.unique);
+        this.segments$ = this.segments.asObservable();
+        this.#preview = new UeVariantPreviewController(this);
+        this.#init = Promise.all([
+            this.itemRepository
+                .requestItems([])
+                .then((resp) => this.personalizations.setValue(resp.data ?? [])),
+            this.segmentsRepository
+                .requestAll()
+                .then((resp) => this.segments.setValue(resp.data ?? [])),
+        ]);
+    }
+    async load() {
+        await this.#init;
+    }
+    async delete(unique) {
+        await this.#init;
+        await this.detailRepository.delete(unique);
+        this.personalizations.remove([unique]);
+    }
+    async requestItems() {
+        const { data } = await this.itemRepository.requestItems([]);
+        this.personalizations.setValue(data ?? []);
+    }
+    async preview(variant) {
+        const page = variant.pages?.[0];
+        if (!variant.umbracoSegmentAlias || !page)
+            return;
+        await this.#preview.preview(page.unique, variant.umbracoSegmentAlias, page.culture);
+    }
+    getPersonalizationByUnique(unique) {
+        return this.personalizations.getValue().find((x) => x.unique === unique);
+    }
+    async getPersonalizationsForPage() {
+        await this.#init;
+        const workspaceContext = await this.getContext(UMB_DOCUMENT_WORKSPACE_CONTEXT);
+        if (!workspaceContext) {
+            throw new Error("Document workspace context is not available.");
+        }
+        const datasetContext = await this.getContext(UMB_PROPERTY_DATASET_CONTEXT);
+        if (!datasetContext) {
+            throw new Error("Property dataset context is not available.");
+        }
+        const unique = workspaceContext.getUnique()?.toString();
+        const culture = datasetContext.getVariantId()?.culture;
+        const contentTypeUnique = workspaceContext
+            .getContentTypeUnique()
+            ?.toString();
+        const cultureMatch = (x) => !x.culture || !culture || x.culture === culture;
+        return (this.personalizations
+            .getValue()
+            .filter((personalization) => personalization.pages.some((page) => page.unique === unique && cultureMatch(page)) ||
+            personalization.contentTypes.some((contentType) => contentType.contentTypeId?.toString() === contentTypeUnique &&
+                cultureMatch(contentType))) ?? []);
+    }
+    destroy() {
+        this.itemRepository.destroy();
+        this.segmentsRepository.destroy();
+        super.destroy();
+    }
+}