@umbraco-engage/backoffice 17.0.0-rc1

package/dist/ab-testing/test/workspace/views/scoring/ab-testing-test-scoring.element.js

@@ -0,0 +1,280 @@
+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_AB_TESTING_TEST_WORKSPACE_CONTEXT } from "../../ab-testing-test-workspace-context.token.js";
+import { html, customElement, state, css, when, } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { umbConfirmModal, umbOpenModal } from "@umbraco-cms/backoffice/modal";
+import { ENGAGE_READONLY_CODE_MODAL_ALIAS, UeTimeFormatOptions, UeVariantPreviewController, } from "../../../../../core/index.js";
+import "../../../collection/elements/ab-test-variant-warning-column-layout.element.js";
+import "../../../collection/elements/ab-test-variant-name-column-layout.element.js";
+import "../../../collection/elements/ab-test-variant-status-column-layout.element.js";
+import "../../../collection/elements/ab-test-variant-percentage-column-layout.element.js";
+const elementName = "ue-ab-testing-test-scoring";
+let UeAbTestingTestWorkspaceViewEditElement = class UeAbTestingTestWorkspaceViewEditElement extends UmbLitElement {
+    #workspaceContext;
+    #preview = new UeVariantPreviewController(this);
+    #previewableVariantStatuses = [
+        "Running",
+        "Warning",
+        "Reliable",
+        "Scheduled",
+        "Disabled",
+    ];
+    #disablableVariantStatuses = [
+        "Running",
+        "Warning",
+        "Reliable",
+        "Scheduled",
+    ];
+    constructor() {
+        super();
+        this._loading = true;
+        this.consumeContext(ENGAGE_AB_TESTING_TEST_WORKSPACE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.#workspaceContext = context;
+            this.observe(context.data, (data) => {
+                this._test = data;
+                this._loading = false;
+            });
+            this.observe(context.generationStatus, (generationStatus) => {
+                this._generationStatus = generationStatus;
+            });
+            this.observe(context.mainGoals, (mainGoals) => {
+                this._mainGoals = mainGoals;
+            });
+        });
+    }
+    #canPreviewVariant(variant) {
+        return (this._test?.test?.umbracoPageVariants?.[0] &&
+            this.#previewableVariantStatuses.includes(variant.status));
+    }
+    #canDisableVariant(variant) {
+        return this.#disablableVariantStatuses.includes(variant.status);
+    }
+    async #disableVariant(variant) {
+        const disable = async () => {
+            await this.#workspaceContext?.disableVariant(variant.id);
+        };
+        await umbConfirmModal(this, {
+            content: this.localize.term("engage_abTesting_confirmDisableVariantDescription"),
+            headline: this.localize.term("engage_abTesting_confirmDisableVariant", variant.name, this._test?.test?.name),
+        })
+            .then(() => disable())
+            .catch(() => { });
+    }
+    // TODO => preview variant
+    #previewVariant(e, variant) {
+        const page = this._test?.test?.umbracoPageVariants?.[0];
+        if (!page)
+            return;
+        this.#preview?.preview(page.unique, null, page.culture, {
+            engagePreviewAbTestVariantId: variant.id,
+        });
+    }
+    async #showCssJs(variant) {
+        umbOpenModal(this, ENGAGE_READONLY_CODE_MODAL_ALIAS, {
+            data: {
+                css: variant.css,
+                javascript: variant.javascript,
+                title: variant.name ?? undefined,
+            },
+        });
+    }
+    #renderGoalsTable(variant) {
+        return html ` <uui-table class="nested">
+      <uui-table-head>
+        <uui-table-head-cell> Goal </uui-table-head-cell>
+        <uui-table-head-cell> Completions </uui-table-head-cell>
+        <uui-table-head-cell> Ratio </uui-table-head-cell>
+        <uui-table-head-cell> Status </uui-table-head-cell>
+      </uui-table-head>
+      ${variant.mainGoalComparisons?.map((comparison) => html `<uui-table-row .class="${comparison.isHurting ? "warning" : ""}"
+            ><uui-table-cell
+              >${this._mainGoals?.[comparison.mainGoalId].name}</uui-table-cell
+            ><uui-table-cell
+              >${comparison.mainGoalCompletions}x
+              <small class="faded"
+                >${this.localize.number(comparison.mainGoalCompletionsTotalValue)}</small
+              ></uui-table-cell
+            >
+            <uui-table-cell>
+              <ue-ab-test-variant-perentage-column-layout
+                .value=${comparison.mainGoalRatio ?? 0}
+              ></ue-ab-test-variant-perentage-column-layout>
+            </uui-table-cell>
+            <uui-table-cell>
+              <ue-ab-test-variant-warning-column-layout
+                .warning=${comparison.isHurting}
+              ></ue-ab-test-variant-warning-column-layout> </uui-table-cell
+          ></uui-table-row>`)}
+    </uui-table>`;
+    }
+    // TODO => localize
+    #renderTable() {
+        return html `
+      ${this._test?.variants?.map((variant, idx) => html `<uui-table>
+            <uui-table-column style="width:250px"></uui-table-column>
+            <uui-table-column style="width:80px"></uui-table-column>
+            <uui-table-column style="width:80px"></uui-table-column>
+            <uui-table-column></uui-table-column>
+            <uui-table-column></uui-table-column>
+            <uui-table-column></uui-table-column>
+            <uui-table-column></uui-table-column>
+            <uui-table-column style="width:100px"></uui-table-column>
+            <uui-table-column style="width:100px"></uui-table-column>
+            <uui-table-head>
+              <uui-table-head-cell>Variant</uui-table-head-cell>
+              <uui-table-head-cell>Visitors</uui-table-head-cell>
+              <uui-table-head-cell>Pageviews</uui-table-head-cell>
+              <uui-table-head-cell>Goal completions</uui-table-head-cell>
+              <uui-table-head-cell>Conversion rate</uui-table-head-cell>
+              <uui-table-head-cell>Macro conversion</uui-table-head-cell>
+              <uui-table-head-cell>Status</uui-table-head-cell>
+              <uui-table-head-cell>CSS / JS</uui-table-head-cell>
+              <uui-table-head-cell></uui-table-head-cell>
+            </uui-table-head>
+            <uui-table-row selectable>
+              <uui-table-cell
+                ><ue-ab-test-variant-name-column-layout
+                  .variant=${variant}
+                  .index=${idx}
+                ></ue-ab-test-variant-name-column-layout
+              ></uui-table-cell>
+              <uui-table-cell
+                >${this.localize.number(variant.totalVisitorsForVariant)}<small
+                  class="faded block"
+                  >${variant.visitorsPortion.toFixed(2)}%</small
+                ></uui-table-cell
+              >
+              <uui-table-cell
+                >${this.localize.number(variant.totalPageviewsForVariant)}</uui-table-cell
+              >
+              <uui-table-cell
+                >${this.localize.number(variant.goalCompletions)}</uui-table-cell
+              >
+              <uui-table-cell>
+                ${variant.conversionRate.toFixed(2)}%
+                ${when(idx > 0 && variant.conversionRateImprovementRelative !== 0, () => html `<div
+                      class="${variant.conversionRateImprovementRelative > 0
+            ? "success"
+            : variant.conversionRateImprovementRelative < 0
+                ? "warning"
+                : ""}"
+                    >
+                      <small
+                        >${variant.conversionRateImprovementRelative.toFixed(1)}%</small
+                      >
+                    </div>`)}
+              </uui-table-cell>
+              <uui-table-cell>
+                <ue-ab-test-variant-warning-column-layout
+                  .warning=${variant.mainGoalWarning}
+                ></ue-ab-test-variant-warning-column-layout>
+              </uui-table-cell>
+              <uui-table-cell>
+                <ue-ab-test-variant-status-column-layout
+                  .status=${variant.status}
+                  .isWinner=${variant.isWinner}
+                ></ue-ab-test-variant-status-column-layout>
+              </uui-table-cell>
+              <uui-table-cell>
+                ${when(variant.css ?? variant.javascript, () => html `<uui-button
+                      compact
+                      @click=${() => this.#showCssJs(variant)}
+                      look="secondary"
+                      ><uui-icon name="icon-code"></uui-icon
+                    ></uui-button>`)}
+              </uui-table-cell>
+              <uui-table-cell>
+                <uui-action-bar>
+                  ${when(this.#canPreviewVariant(variant), () => html ` <uui-button
+                      compact
+                      label="Preview"
+                      @click=${(e) => this.#previewVariant(e, variant)}
+                      look="secondary"
+                      ><uui-icon name="icon-preview"></uui-icon
+                    ></uui-button>`)}
+                  ${when(idx > 0 && this.#canDisableVariant(variant), () => html ` <uui-button
+                      compact
+                      label="Disable"
+                      @click=${() => this.#disableVariant(variant)}
+                      look="secondary"
+                      ><uui-icon name="icon-block"></uui-icon
+                    ></uui-button>`)}</uui-action-bar
+                >
+              </uui-table-cell>
+            </uui-table-row>
+          </uui-table>
+          ${this.#renderGoalsTable(variant)} `)}
+    `;
+    }
+    render() {
+        return html `<umb-body-layout>
+      <uui-box
+        .headline=${this.localize.term("engage_abTesting_scoringOverview")}
+      >
+        ${when(this._generationStatus?.lastGenerated, () => html ` <small slot="header-actions"
+            >${this.localize.term("engage_lastUpdated", this.localize.date(this._generationStatus.lastGenerated, UeTimeFormatOptions))}</small
+          >`)}
+        ${when(this._loading, () => html `<uui-loader></uui-loader>`, () => this.#renderTable())}
+      </uui-box>
+      <ue-ab-testing-test-indication></ue-ab-testing-test-indication>
+    </umb-body-layout>`;
+    }
+    static { this.styles = [
+        css `
+      .block {
+        display: block;
+      }
+
+      .faded {
+        opacity: 0.5;
+      }
+
+      uui-box {
+        --uui-box-default-padding: 0;
+      }
+
+      uui-table.nested {
+        display: none;
+        padding: 0 var(--uui-size-10);
+        box-sizing: border-box;
+        width: 100%;
+      }
+
+      uui-table:has([selected]) + .nested {
+        display: table;
+      }
+
+      uui-table-column {
+        width: 150px;
+      }
+
+      .nested + uui-table uui-table-head {
+        visibility: collapse;
+      }
+    `,
+    ]; }
+};
+__decorate([
+    state()
+], UeAbTestingTestWorkspaceViewEditElement.prototype, "_test", void 0);
+__decorate([
+    state()
+], UeAbTestingTestWorkspaceViewEditElement.prototype, "_generationStatus", void 0);
+__decorate([
+    state()
+], UeAbTestingTestWorkspaceViewEditElement.prototype, "_mainGoals", void 0);
+__decorate([
+    state()
+], UeAbTestingTestWorkspaceViewEditElement.prototype, "_loading", void 0);
+UeAbTestingTestWorkspaceViewEditElement = __decorate([
+    customElement(elementName)
+], UeAbTestingTestWorkspaceViewEditElement);
+export { UeAbTestingTestWorkspaceViewEditElement };
+export default UeAbTestingTestWorkspaceViewEditElement;

package/dist/ab-testing/umbraco-package.d.ts

@@ -0,0 +1,8 @@
+export declare const name = "Umbraco.Engage.AbTesting";
+export declare const extensions: {
+    name: string;
+    alias: string;
+    type: string;
+    js: () => Promise<typeof import("./manifests.js")>;
+}[];
+export * from "./index.js";

package/dist/ab-testing/umbraco-package.js

@@ -0,0 +1,10 @@
+export const name = "Umbraco.Engage.AbTesting";
+export const extensions = [
+    {
+        name: "Engage AbTesting Bundle",
+        alias: "Engage.Bundle.AbTesting",
+        type: "bundle",
+        js: () => import("./manifests.js"),
+    },
+];
+export * from "./index.js";

package/dist/ab-testing/workspace-view/abtesting-document-workspace-context.d.ts

@@ -0,0 +1,11 @@
+import { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type ProjectAbTestModel } from "../../generated/index.js";
+export declare class UeAbTestingDocumentWorkspaceContext extends UmbContextBase {
+    #private;
+    readonly IS_AB_TESTING_DOCUMENT_WORKSPACE_CONTEXT = true;
+    data: import("rxjs").Observable<ProjectAbTestModel[]>;
+    constructor(host: UmbControllerHost);
+    load(unique: string): Promise<void>;
+    reload(): Promise<void>;
+}

package/dist/ab-testing/workspace-view/abtesting-document-workspace-context.js

@@ -0,0 +1,35 @@
+import { ENGAGE_AB_TESTING_DOCUMENT_WORKSPACE_CONTEXT } from "./abtesting-document-workspace-context.token.js";
+import { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/document";
+import { UmbArrayState } from "@umbraco-cms/backoffice/observable-api";
+import { tryExecute } from "@umbraco-cms/backoffice/resources";
+import { ABTestService, } from "../../generated/index.js";
+export class UeAbTestingDocumentWorkspaceContext extends UmbContextBase {
+    #data;
+    #unique;
+    constructor(host) {
+        super(host, ENGAGE_AB_TESTING_DOCUMENT_WORKSPACE_CONTEXT);
+        this.IS_AB_TESTING_DOCUMENT_WORKSPACE_CONTEXT = true;
+        this.#data = new UmbArrayState([], (x) => x.abTestId);
+        this.data = this.#data.asObservable();
+        this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.observe(context.unique, (unique) => {
+                if (!unique)
+                    return;
+                this.load(unique);
+            });
+        }).skipHost();
+    }
+    async load(unique) {
+        const { data } = await tryExecute(this._host, ABTestService.getAbTestPage({ query: { unique } }));
+        this.#unique = unique;
+        this.#data.setValue(data ?? []);
+    }
+    async reload() {
+        if (!this.#unique)
+            return;
+        await this.load(this.#unique);
+    }
+}

package/dist/ab-testing/workspace-view/abtesting-document-workspace-context.token.d.ts

@@ -0,0 +1,4 @@
+import type { UeAbTestingDocumentWorkspaceContext } from "./abtesting-document-workspace-context.js";
+import type { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+export declare const ENGAGE_AB_TESTING_DOCUMENT_WORKSPACE_CONTEXT: UmbContextToken<UmbContextBase, UeAbTestingDocumentWorkspaceContext>;

package/dist/ab-testing/workspace-view/abtesting-document-workspace-context.token.js

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

package/dist/ab-testing/workspace-view/abtesting-workspace-view.element.d.ts

@@ -0,0 +1,14 @@
+import { UeContentScreenBaseElement } from "../../core/index.js";
+declare const elementName = "ue-abtesting-workspace-view";
+export declare class UeAbTestingWorkspaceViewElement extends UeContentScreenBaseElement {
+    #private;
+    constructor();
+    renderSidebar(): import("lit-html").TemplateResult<1>;
+    renderContent(): import("lit-html").TemplateResult<1>;
+}
+export default UeAbTestingWorkspaceViewElement;
+declare global {
+    interface HTMLElementTagNameMap {
+        [elementName]: UeAbTestingWorkspaceViewElement;
+    }
+}

package/dist/ab-testing/workspace-view/abtesting-workspace-view.element.js

@@ -0,0 +1,76 @@
+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 { UeAbTestingDocumentWorkspaceContext } from "./abtesting-document-workspace-context.js";
+import { customElement, html } from "@umbraco-cms/backoffice/external/lit";
+import { UeContentScreenBaseElement } from "../../core/index.js";
+import { UmbModalRouteRegistrationController } from "@umbraco-cms/backoffice/router";
+import { UMB_WORKSPACE_MODAL } from "@umbraco-cms/backoffice/workspace";
+import { ENGAGE_AB_TESTING_TEST_ENTITY_TYPE } from "../umbraco-package.js";
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/document";
+const elementName = "ue-abtesting-workspace-view";
+let UeAbTestingWorkspaceViewElement = class UeAbTestingWorkspaceViewElement extends UeContentScreenBaseElement {
+    #modalPath;
+    #documentWorkspaceContext;
+    #workspaceContext;
+    constructor() {
+        super();
+        this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, (context) => {
+            this.#documentWorkspaceContext = context;
+        });
+        new UmbModalRouteRegistrationController(this, UMB_WORKSPACE_MODAL)
+            .addAdditionalPath(ENGAGE_AB_TESTING_TEST_ENTITY_TYPE)
+            .onSetup(async () => ({
+            data: {
+                entityType: ENGAGE_AB_TESTING_TEST_ENTITY_TYPE,
+                umbracoPageVariants: [
+                    {
+                        id: 0,
+                        unique: this.#documentWorkspaceContext?.getUnique()?.toString(),
+                        culture: this.#documentWorkspaceContext?.splitView
+                            ?.getActiveVariants()
+                            .at(0)?.culture,
+                    },
+                ],
+            },
+            modal: {
+                size: "large",
+            },
+        }))
+            .onReject(async () => await this.#workspaceContext?.reload())
+            .onSubmit(async () => await this.#workspaceContext?.reload())
+            .observeRouteBuilder((routeBuilder) => {
+            this.#modalPath = routeBuilder({});
+        });
+        this.#workspaceContext = new UeAbTestingDocumentWorkspaceContext(this);
+    }
+    async #onAddTest() {
+        history.pushState({}, "", `${this.#modalPath}create`);
+    }
+    renderSidebar() {
+        return html `<uui-box
+      .headline=${this.localize.term("engage_abTesting_startTest")}
+    >
+      <p style="margin-top:0">
+        ${this.localize.term("engage_abTesting_startTestDescription")}
+      </p>
+      <uui-button
+        .label=${this.localize.term("engage_abTesting_createNewTest")}
+        @click=${this.#onAddTest}
+        look="primary"
+        color="positive"
+      ></uui-button
+    ></uui-box>`;
+    }
+    renderContent() {
+        return html `<ue-ab-testing-document-test-list></ue-ab-testing-document-test-list>`;
+    }
+};
+UeAbTestingWorkspaceViewElement = __decorate([
+    customElement(elementName)
+], UeAbTestingWorkspaceViewElement);
+export { UeAbTestingWorkspaceViewElement };
+export default UeAbTestingWorkspaceViewElement;

package/dist/ab-testing/workspace-view/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./abtesting-document-workspace-context.js";
+export * from "./abtesting-document-workspace-context.token.js";

package/dist/ab-testing/workspace-view/index.js

@@ -0,0 +1,2 @@
+export * from "./abtesting-document-workspace-context.js";
+export * from "./abtesting-document-workspace-context.token.js";

package/dist/analytics/analytics-context.d.ts

@@ -0,0 +1,26 @@
+import type { UeAnalyticsContextDefaultSettings } from "./entities.js";
+import { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { type AnalyticsQueryGetModel } from "../generated/index.js";
+interface AnalyticsConfigType extends Partial<AnalyticsQueryGetModel> {
+}
+export declare class UeAnalyticsContext extends UmbContextBase {
+    #private;
+    readonly STORAGE_KEY = "ue:analyticsContext";
+    readonly DEFAULT_DAY_RANGE = 30;
+    settings: import("rxjs").Observable<UeAnalyticsContextDefaultSettings>;
+    groupBy: import("rxjs").Observable<import("./entities.js").AnalyticsGroupBy>;
+    drilldown: import("rxjs").Observable<Record<string, any> | undefined>;
+    constructor(host: UmbControllerHost);
+    queryBase(query: AnalyticsConfigType): Promise<import("../generated/index.js").AnalyticsQueryResultModel>;
+    query(config: AnalyticsConfigType): Promise<{
+        queryResults: import("../generated/index.js").AnalyticsQueryResultModel[];
+        primaryQueryConfig: Partial<AnalyticsQueryGetModel>;
+        secondaryQueryConfig: Partial<AnalyticsQueryGetModel> | undefined;
+    }>;
+    updateSettings(settings: Partial<UeAnalyticsContextDefaultSettings>): void;
+    setDrilldown(drilldown?: Record<string, any>): void;
+}
+export { UeAnalyticsContext as api };
+export declare const ENGAGE_ANALYTICS_CONTEXT: UmbContextToken<UeAnalyticsContext, UeAnalyticsContext>;

package/dist/analytics/analytics-context.js

@@ -0,0 +1,182 @@
+import { ENGAGE_ANALYTICS_CONTEXT_ALIAS } from "./constants.js";
+import { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+import { UmbObjectState } from "@umbraco-cms/backoffice/observable-api";
+import { tryExecute } from "@umbraco-cms/backoffice/resources";
+import { filter, firstValueFrom, map, } from "@umbraco-cms/backoffice/external/rxjs";
+import { AnalyticsService, } from "../generated/index.js";
+import { ENGAGE_DATERANGE_MANAGER } from "../core/index.js";
+import { DATEPICKER_MODES } from "../constants.js";
+export class UeAnalyticsContext extends UmbContextBase {
+    #dateRangeManager;
+    #settings;
+    #drilldown;
+    constructor(host) {
+        super(host, ENGAGE_ANALYTICS_CONTEXT);
+        this.STORAGE_KEY = "ue:analyticsContext";
+        this.DEFAULT_DAY_RANGE = 30;
+        this.#settings = new UmbObjectState({
+            includeNodeDescendants: false,
+            groupBy: "day",
+            dateRange: undefined, // This will be set by the date range context
+        });
+        this.settings = this.#settings.asObservable();
+        this.groupBy = this.#settings.asObservablePart((x) => x?.groupBy);
+        this.#drilldown = new UmbObjectState(undefined);
+        this.drilldown = this.#drilldown.asObservable();
+        this.consumeContext(ENGAGE_DATERANGE_MANAGER, async (context) => {
+            if (!context)
+                return;
+            this.#dateRangeManager = context;
+            await this.#setFromStorage();
+            // use the function to also update local storage
+            this.observe(this.#dateRangeManager.config, (config) => {
+                if (!config)
+                    return;
+                this.updateSettings({ dateRange: config });
+            });
+        });
+    }
+    async #setFromStorage() {
+        if (!this.#dateRangeManager)
+            return;
+        const fromStorage = localStorage.getItem(this.STORAGE_KEY);
+        let value = (fromStorage ? JSON.parse(fromStorage) : this.#settings.getValue());
+        if (!value.dateRange?.primary.range.from) {
+            const range = this.#dateRangeManager.getValue();
+            const existing = value.dateRange?.primary.range;
+            const empty = { from: "", to: "" };
+            value = {
+                ...value,
+                dateRange: {
+                    primary: {
+                        mode: value.dateRange?.primary.mode ?? DATEPICKER_MODES.LAST_7_DAYS,
+                        range: existing ?? range ?? empty,
+                    },
+                    compare: value.dateRange?.compare ?? false,
+                    secondary: {
+                        range: empty,
+                    },
+                },
+            };
+        }
+        this.#settings.update({
+            includeNodeDescendants: value.includeNodeDescendants ?? false,
+            groupBy: value.groupBy ?? "day",
+            dateRange: value.dateRange,
+        });
+        this.#dateRangeManager.updateConfig(value.dateRange);
+    }
+    #ensureDates(query) {
+        if (!query.endDate) {
+            query.endDate = new Date().toISOString();
+        }
+        if (!query.startDate) {
+            const startDate = new Date();
+            startDate.setDate(-this.DEFAULT_DAY_RANGE);
+            startDate.setHours(0, 0, 0, 0);
+            query.startDate = startDate.toISOString();
+        }
+    }
+    // TODO => ensure this works with drilldown (it won't currently as it replaces the filter)
+    async #setNodeFilter(query) {
+        if (!query.documentUnique)
+            return;
+        query.filter = `NodeId=='${query.documentUnique}${this.#settings.getValue().includeNodeDescendants ? "+" : ""}'`;
+        if (query.culture !== undefined && query.culture !== "invariant") {
+            query.filter += `;NodeCulture=='${query.culture}'`;
+        }
+    }
+    #setDrilldown(query) {
+        query.filter = null;
+        const drilldown = this.#drilldown.getValue() ?? {};
+        const drilldownArray = Object.keys(drilldown)
+            .filter((key) => drilldown?.[key] !== null)
+            .map((key) => `${key}=='${drilldown?.[key]}'`);
+        if (!drilldownArray.length)
+            return;
+        const baseFilter = query.filter ?? "";
+        if (baseFilter)
+            // Combine the drilldown array with the filter from the prefab
+            query.filter = drilldownArray
+                .map((dd) => baseFilter + ";" + dd)
+                .join(";");
+        else {
+            query.filter = drilldownArray.join(";");
+        }
+    }
+    #mapQuery(query) {
+        return {
+            ascending: query.ascending,
+            dimensions: query.dimensions,
+            endDate: query.endDate,
+            filter: query.filter,
+            metrics: query.metrics,
+            page: query.page,
+            pageSize: query.pageSize,
+            realtime: query.realtime,
+            sort: query.sort ?? query.dimensions?.[0],
+            startDate: query.startDate,
+        };
+    }
+    async #awaitDateRange() {
+        const dateRange = await firstValueFrom(this.settings.pipe(filter((settings) => !!settings.dateRange), map((settings) => settings.dateRange)));
+        if (!dateRange)
+            throw new Error("DateRange is missing");
+        return dateRange;
+    }
+    async #buildPrimaryQueryConfig(config) {
+        const dateRange = await this.#awaitDateRange();
+        return {
+            ...config,
+            ...{
+                startDate: dateRange.primary.range.from,
+                endDate: dateRange.primary.range.to,
+            },
+        };
+    }
+    async #buildSecondaryQueryConfig(config) {
+        const dateRange = await this.#awaitDateRange();
+        if (!dateRange.compare)
+            return;
+        return {
+            ...config,
+            ...{
+                startDate: dateRange.secondary.range.from,
+                endDate: dateRange.secondary.range.to,
+            },
+        };
+    }
+    async #query(query) {
+        this.#ensureDates(query);
+        this.#setDrilldown(query);
+        this.#setNodeFilter(query);
+        const getModel = this.#mapQuery(query);
+        const { data } = await tryExecute(this, AnalyticsService.postAnalyticsQuery({
+            body: getModel,
+        }));
+        return data;
+    }
+    async queryBase(query) {
+        return this.#query(query);
+    }
+    async query(config) {
+        const primaryQueryConfig = await this.#buildPrimaryQueryConfig(config);
+        const secondaryQueryConfig = await this.#buildSecondaryQueryConfig(config);
+        const queryPromises = [this.#query(primaryQueryConfig)];
+        if (secondaryQueryConfig) {
+            queryPromises.push(this.#query(secondaryQueryConfig));
+        }
+        const queryResults = await Promise.all(queryPromises);
+        return { queryResults, primaryQueryConfig, secondaryQueryConfig };
+    }
+    updateSettings(settings) {
+        this.#settings.update(settings);
+        localStorage.setItem(this.STORAGE_KEY, JSON.stringify(this.#settings.getValue()));
+    }
+    setDrilldown(drilldown) {
+        this.#drilldown.setValue(drilldown);
+    }
+}
+export { UeAnalyticsContext as api };
+export const ENGAGE_ANALYTICS_CONTEXT = new UmbContextToken(ENGAGE_ANALYTICS_CONTEXT_ALIAS);