@umbraco-engage/backoffice 17.0.0-rc1

package/dist/core/components/variant-pickers/variant-picker-base.element.d.ts

@@ -0,0 +1,20 @@
+import { type TemplateResult } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { type UmbPropertyEditorConfigCollection } from "@umbraco-cms/backoffice/property-editor";
+export declare abstract class UeVariantPickerBaseElement<EntityModel extends {
+    culture?: string | null;
+}> extends UmbLitElement {
+    #private;
+    protected languageOptions: Array<Option>;
+    protected culture?: string;
+    protected emptyMessage?: string;
+    set value(value: Array<EntityModel> | undefined);
+    get value(): Array<EntityModel> | undefined;
+    set config(config: UmbPropertyEditorConfigCollection | undefined);
+    abstract renderPicker(): TemplateResult;
+    abstract onSelectionChange(e: Event): void;
+    abstract onValueUpdated(): void;
+    constructor();
+    protected onLanguageChange(e: Event): void;
+    render(): TemplateResult<1>;
+}

package/dist/core/components/variant-pickers/variant-picker-base.element.js

@@ -0,0 +1,68 @@
+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 { UmbChangeEvent } from "@umbraco-cms/backoffice/event";
+import { html, property, state, } from "@umbraco-cms/backoffice/external/lit";
+import { UMB_APP_LANGUAGE_CONTEXT } from "@umbraco-cms/backoffice/language";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+export class UeVariantPickerBaseElement extends UmbLitElement {
+    #value;
+    set value(value) {
+        this.#value = value;
+        this.onValueUpdated();
+    }
+    get value() {
+        return this.#value;
+    }
+    set config(config) {
+        if (!config)
+            return;
+        this.emptyMessage = this.localize.string(config.getValueByAlias("emptyMessage"));
+    }
+    constructor() {
+        super();
+        this.languageOptions = [];
+        this.consumeContext(UMB_APP_LANGUAGE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.observe(context.languages, (languages) => {
+                this.languageOptions =
+                    languages?.map((l, i) => ({
+                        name: l.name,
+                        value: l.unique,
+                        selected: (languages.length === 1 && i == 0) ||
+                            this.value?.at(0)?.culture === l.unique,
+                    })) ?? [];
+                this.culture = this.languageOptions.at(0)?.value;
+            });
+        });
+    }
+    onLanguageChange(e) {
+        this.culture = e.target.value.toString();
+        this.value =
+            this.value?.map((v) => ({ ...v, culture: this.culture })) ?? [];
+        this.dispatchEvent(new UmbChangeEvent());
+    }
+    render() {
+        return html `<uui-select
+        .options=${this.languageOptions}
+        @change=${this.onLanguageChange}
+      ></uui-select>
+      ${this.renderPicker()}`;
+    }
+}
+__decorate([
+    state()
+], UeVariantPickerBaseElement.prototype, "languageOptions", void 0);
+__decorate([
+    state()
+], UeVariantPickerBaseElement.prototype, "culture", void 0);
+__decorate([
+    state()
+], UeVariantPickerBaseElement.prototype, "emptyMessage", void 0);
+__decorate([
+    property({ type: Array })
+], UeVariantPickerBaseElement.prototype, "value", null);

package/dist/core/components/workspace-editor-base.element.d.ts

@@ -0,0 +1,23 @@
+import type { UmbContextToken } from "@umbraco-cms/backoffice/context-api";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { type Observable } from "@umbraco-cms/backoffice/observable-api";
+import type { UmbSubmittableWorkspaceContext, UmbWorkspaceViewElement } from "@umbraco-cms/backoffice/workspace";
+import type { UeExtractModel } from "../entities.js";
+export interface UeWorkspaceEditorBaseCtorArgs<EntityModel> {
+    workspaceAlias: string;
+    createLabel?: string;
+    editLabel?: string;
+    editLabelArgs?: (data?: EntityModel) => Array<string | undefined> | undefined;
+}
+export declare abstract class UeWorkspaceEditorBaseElement<WorkspaceContext extends UmbSubmittableWorkspaceContext & {
+    getData: () => UeExtractModel<WorkspaceContext> | undefined;
+    data: Observable<UeExtractModel<WorkspaceContext> | undefined>;
+}> extends UmbLitElement implements UmbWorkspaceViewElement {
+    private _headline?;
+    protected _isNew: boolean;
+    protected args: UeWorkspaceEditorBaseCtorArgs<UeExtractModel<WorkspaceContext>>;
+    protected context?: WorkspaceContext;
+    constructor(contextToken: UmbContextToken<UmbSubmittableWorkspaceContext, WorkspaceContext>, args: UeWorkspaceEditorBaseCtorArgs<UeExtractModel<WorkspaceContext>>);
+    render(): import("lit-html").TemplateResult<1>;
+    destroy(): void;
+}

package/dist/core/components/workspace-editor-base.element.js

@@ -0,0 +1,52 @@
+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, state } from "@umbraco-cms/backoffice/external/lit";
+import { UmbLitElement } from "@umbraco-cms/backoffice/lit-element";
+import { observeMultiple, } from "@umbraco-cms/backoffice/observable-api";
+export class UeWorkspaceEditorBaseElement extends UmbLitElement {
+    constructor(contextToken, args) {
+        super();
+        this._isNew = true;
+        this.args = args;
+        this.consumeContext(contextToken, (context) => {
+            if (!context)
+                return;
+            this.context = context;
+            this.observe(observeMultiple([this.context.isNew, this.context.data]), ([isNew, data]) => {
+                if (isNew === undefined || !data)
+                    return;
+                this._isNew = isNew;
+                if (this._isNew) {
+                    this._headline = this.localize.term(this.args.createLabel ?? "");
+                }
+                else {
+                    this._headline = this.localize.term(this.args.editLabel ?? "", (this.args.editLabelArgs?.(context?.getData()) ?? []).filter((arg) => arg !== undefined));
+                }
+            });
+        });
+    }
+    render() {
+        return html `<umb-workspace-editor
+      main-no-padding
+      alias=${this.args.workspaceAlias}
+    >
+      <div id="header" slot="header">
+        <h3 id="headline">${this._headline}</h3>
+      </div>
+    </umb-workspace-editor>`;
+    }
+    destroy() {
+        this.context?.destroy();
+        super.destroy();
+    }
+}
+__decorate([
+    state()
+], UeWorkspaceEditorBaseElement.prototype, "_headline", void 0);
+__decorate([
+    state()
+], UeWorkspaceEditorBaseElement.prototype, "_isNew", void 0);

package/dist/core/conditions/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const ENGAGE_WORKSPACE_PROPERTY_HAS_VALUE_CONDITION_ALIAS = "Engage.Condition.WorkspacePropertyHasValue";
+export declare const ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS = "Engage.Condition.EntityIsNotNew";
+export declare const ENGAGE_EXTENSION_VISIBILITY_CONDITION_ALIAS = "Engage.Condition.ExtensionVisibility";
+export declare const ENGAGE_USER_GROUP_PERMISSIONS_CONDITION_ALIAS = "Engage.Condition.UserGroup.Permissions";
+export declare const ENGAGE_DOCUMENT_TYPE_PERMISSIONS_CONDITION_ALIAS = "Engage.Condition.DocumentType.Permissions";
+export declare const ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS = "Engage.Condition.WorkspaceViewActive";

package/dist/core/conditions/constants.js

@@ -0,0 +1,6 @@
+export const ENGAGE_WORKSPACE_PROPERTY_HAS_VALUE_CONDITION_ALIAS = "Engage.Condition.WorkspacePropertyHasValue";
+export const ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS = "Engage.Condition.EntityIsNotNew";
+export const ENGAGE_EXTENSION_VISIBILITY_CONDITION_ALIAS = "Engage.Condition.ExtensionVisibility";
+export const ENGAGE_USER_GROUP_PERMISSIONS_CONDITION_ALIAS = "Engage.Condition.UserGroup.Permissions";
+export const ENGAGE_DOCUMENT_TYPE_PERMISSIONS_CONDITION_ALIAS = "Engage.Condition.DocumentType.Permissions";
+export const ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS = "Engage.Condition.WorkspaceViewActive";

package/dist/core/conditions/document-type-accessible.condition.d.ts

@@ -0,0 +1,8 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import type { UeDocumentTypePermissionConditionConfig } from "./types.js";
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from "@umbraco-cms/backoffice/extension-api";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+export declare class UeDocumentTypePermissionCondition extends UmbConditionBase<UeDocumentTypePermissionConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UeDocumentTypePermissionConditionConfig>);
+}
+export { UeDocumentTypePermissionCondition as api };

package/dist/core/conditions/document-type-accessible.condition.js

@@ -0,0 +1,22 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import { ENGAGE_CONTEXT } from "../context/index.js";
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/document";
+export class UeDocumentTypePermissionCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, async (workspaceContext) => {
+            if (!workspaceContext)
+                return;
+            const engageContext = await this.getContext(ENGAGE_CONTEXT);
+            if (!engageContext)
+                return;
+            const contentType = workspaceContext.structure.getOwnerContentType();
+            this.observe(engageContext?.documentTypePermissions, (permissions) => {
+                if (!permissions)
+                    return;
+                this.permitted = engageContext.getDocumentTypePermission(contentType?.name ?? "", args.config.match);
+            });
+        });
+    }
+}
+export { UeDocumentTypePermissionCondition as api };

package/dist/core/conditions/entity-is-not-new.condition.d.ts

@@ -0,0 +1,8 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from "@umbraco-cms/backoffice/extension-api";
+import { UeEntityIsNewConditionConfig } from "./types.js";
+export declare class UeEntityIsNotNewWorkspaceCondition extends UmbConditionBase<UeEntityIsNewConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UeEntityIsNewConditionConfig>);
+}
+export { UeEntityIsNotNewWorkspaceCondition as api };

package/dist/core/conditions/entity-is-not-new.condition.js

@@ -0,0 +1,13 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import { UMB_SUBMITTABLE_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/workspace";
+export class UeEntityIsNotNewWorkspaceCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_SUBMITTABLE_WORKSPACE_CONTEXT, (context) => {
+            this.observe(context?.isNew, (isNew) => {
+                this.permitted = isNew === (args.config.invert ? true : false);
+            });
+        });
+    }
+}
+export { UeEntityIsNotNewWorkspaceCondition as api };

package/dist/core/conditions/extension-visibility.condition.d.ts

@@ -0,0 +1,11 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from "@umbraco-cms/backoffice/extension-api";
+import type { UeExtensionVisibilityConditionConfig } from "./types.js";
+export declare class UeExtensionVisibilityCondition extends UmbConditionBase<UeExtensionVisibilityConditionConfig> implements UmbExtensionCondition {
+    #private;
+    splitViewActive: boolean;
+    licensed: boolean;
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UeExtensionVisibilityConditionConfig>);
+}
+export { UeExtensionVisibilityCondition as api };

package/dist/core/conditions/extension-visibility.condition.js

@@ -0,0 +1,30 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import { ENGAGE_CONTEXT } from "../context/index.js";
+import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/document";
+export class UeExtensionVisibilityCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.splitViewActive = false;
+        this.licensed = false;
+        this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.observe(context.splitView.splitViewActive, (splitViewActive) => {
+                this.splitViewActive = splitViewActive;
+                this.#setPermitted();
+            });
+        });
+        this.consumeContext(ENGAGE_CONTEXT, (context) => {
+            this.observe(context?.licensedFeatures, (licensedFeatures) => {
+                this.licensed =
+                    args.config.allOf?.every((feature) => licensedFeatures?.[feature]) ??
+                        false;
+                this.#setPermitted();
+            });
+        });
+    }
+    #setPermitted() {
+        this.permitted = !this.splitViewActive && this.licensed;
+    }
+}
+export { UeExtensionVisibilityCondition as api };

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

@@ -0,0 +1 @@
+export * from './constants.js';

package/dist/core/conditions/index.js

@@ -0,0 +1 @@
+export * from './constants.js';

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

@@ -0,0 +1,37 @@
+import { UeEntityIsNotNewWorkspaceCondition } from "./entity-is-not-new.condition.js";
+import { UeExtensionVisibilityCondition } from "./extension-visibility.condition.js";
+import { UeWorkspacePropertyHasValueCondition } from "./workspace-property-has-value.condition.js";
+import { UeUserGroupPermissionCondition } from "./user-group-accessible.condition.js";
+import { UeDocumentTypePermissionCondition } from "./document-type-accessible.condition.js";
+import { UeWorkspaceViewIsActiveWorkspaceCondition } from "./workspace-view-active.condition.js";
+export declare const manifests: ({
+    type: string;
+    name: string;
+    alias: string;
+    api: typeof UeWorkspacePropertyHasValueCondition;
+} | {
+    type: string;
+    name: string;
+    alias: string;
+    api: typeof UeEntityIsNotNewWorkspaceCondition;
+} | {
+    type: string;
+    name: string;
+    alias: string;
+    api: typeof UeExtensionVisibilityCondition;
+} | {
+    type: string;
+    name: string;
+    alias: string;
+    api: typeof UeUserGroupPermissionCondition;
+} | {
+    type: string;
+    name: string;
+    alias: string;
+    api: typeof UeDocumentTypePermissionCondition;
+} | {
+    type: string;
+    name: string;
+    alias: string;
+    api: typeof UeWorkspaceViewIsActiveWorkspaceCondition;
+})[];

package/dist/core/conditions/manifests.js

@@ -0,0 +1,45 @@
+import { ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS, ENGAGE_EXTENSION_VISIBILITY_CONDITION_ALIAS, ENGAGE_WORKSPACE_PROPERTY_HAS_VALUE_CONDITION_ALIAS, ENGAGE_USER_GROUP_PERMISSIONS_CONDITION_ALIAS, ENGAGE_DOCUMENT_TYPE_PERMISSIONS_CONDITION_ALIAS, ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS, } from "./constants.js";
+import { UeEntityIsNotNewWorkspaceCondition } from "./entity-is-not-new.condition.js";
+import { UeExtensionVisibilityCondition } from "./extension-visibility.condition.js";
+import { UeWorkspacePropertyHasValueCondition } from "./workspace-property-has-value.condition.js";
+import { UeUserGroupPermissionCondition } from "./user-group-accessible.condition.js";
+import { UeDocumentTypePermissionCondition } from "./document-type-accessible.condition.js";
+import { UeWorkspaceViewIsActiveWorkspaceCondition } from "./workspace-view-active.condition.js";
+export const manifests = [
+    {
+        type: "condition",
+        name: "Engage Workspace Property Has Value Condition",
+        alias: ENGAGE_WORKSPACE_PROPERTY_HAS_VALUE_CONDITION_ALIAS,
+        api: UeWorkspacePropertyHasValueCondition,
+    },
+    {
+        type: "condition",
+        name: "Engage Entity Is Not New Condition",
+        alias: ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS,
+        api: UeEntityIsNotNewWorkspaceCondition,
+    },
+    {
+        type: "condition",
+        name: "Engage Extension Visibility Condition",
+        alias: ENGAGE_EXTENSION_VISIBILITY_CONDITION_ALIAS,
+        api: UeExtensionVisibilityCondition,
+    },
+    {
+        type: "condition",
+        name: "User Group Permission Condition",
+        alias: ENGAGE_USER_GROUP_PERMISSIONS_CONDITION_ALIAS,
+        api: UeUserGroupPermissionCondition,
+    },
+    {
+        type: "condition",
+        name: "Document Type Permission Condition",
+        alias: ENGAGE_DOCUMENT_TYPE_PERMISSIONS_CONDITION_ALIAS,
+        api: UeDocumentTypePermissionCondition,
+    },
+    {
+        type: "condition",
+        name: "Active Workspace View Condition",
+        alias: ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS,
+        api: UeWorkspaceViewIsActiveWorkspaceCondition,
+    },
+];

package/dist/core/conditions/types.d.ts

@@ -0,0 +1,33 @@
+import type { UmbConditionConfigBase } from "@umbraco-cms/backoffice/extension-api";
+import type { ENGAGE_DOCUMENT_TYPE_PERMISSIONS_CONDITION_ALIAS, ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS, ENGAGE_EXTENSION_VISIBILITY_CONDITION_ALIAS, ENGAGE_USER_GROUP_PERMISSIONS_CONDITION_ALIAS, ENGAGE_WORKSPACE_PROPERTY_HAS_VALUE_CONDITION_ALIAS, ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS } from "./constants.js";
+import type { UeDocumentTypePermissionMap, UeUserGroupPermissionMap } from "../entities.js";
+export interface UeWorkspacePropertyHasValueConditionConfig extends UmbConditionConfigBase<typeof ENGAGE_WORKSPACE_PROPERTY_HAS_VALUE_CONDITION_ALIAS> {
+    observablePropertyAlias?: string;
+    value?: string | boolean | number;
+}
+export interface UeExtensionVisibilityConditionConfig extends UmbConditionConfigBase<typeof ENGAGE_EXTENSION_VISIBILITY_CONDITION_ALIAS> {
+    allOf?: string[];
+}
+export interface UeEntityIsNewConditionConfig extends UmbConditionConfigBase<typeof ENGAGE_ENTITY_IS_NOT_NEW_CONDITION_ALIAS> {
+    invert?: boolean;
+}
+export interface UeUserGroupPermissionConditionConfig extends UmbConditionConfigBase<typeof ENGAGE_USER_GROUP_PERMISSIONS_CONDITION_ALIAS> {
+    match: string & keyof UeUserGroupPermissionMap;
+}
+export interface UeDocumentTypePermissionConditionConfig extends UmbConditionConfigBase<typeof ENGAGE_DOCUMENT_TYPE_PERMISSIONS_CONDITION_ALIAS> {
+    match: string & keyof UeDocumentTypePermissionMap;
+}
+export interface UeWorkspaceViewActiveConditionConfig extends UmbConditionConfigBase<typeof ENGAGE_WORKSPACE_VIEW_ACTIVE_CONDITION_ALIAS> {
+    match?: string;
+    oneOf?: Array<string>;
+}
+declare global {
+    interface UmbExtensionConditionConfigMap {
+        ueWorkspacePropertyHasValue: UeWorkspacePropertyHasValueConditionConfig;
+        ueExtensionVisibility: UeExtensionVisibilityConditionConfig;
+        ueDocumentTypePermissionConditionConfig: UeDocumentTypePermissionConditionConfig;
+        ueUserGroupPermissionConditionConfig: UeUserGroupPermissionConditionConfig;
+        ueEntityIsNewConditionConfig: UeEntityIsNewConditionConfig;
+        ueWorkspaceViewActiveConditionConfig: UeWorkspaceViewActiveConditionConfig;
+    }
+}

package/dist/core/conditions/types.js

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

package/dist/core/conditions/user-group-accessible.condition.d.ts

@@ -0,0 +1,8 @@
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from "@umbraco-cms/backoffice/extension-api";
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import type { UeUserGroupPermissionConditionConfig } from "./types.js";
+export declare class UeUserGroupPermissionCondition extends UmbConditionBase<UeUserGroupPermissionConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UeUserGroupPermissionConditionConfig>);
+}
+export { UeUserGroupPermissionCondition as api };

package/dist/core/conditions/user-group-accessible.condition.js

@@ -0,0 +1,17 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import { ENGAGE_CONTEXT } from "../context/index.js";
+export class UeUserGroupPermissionCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(ENGAGE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.observe(context.userGroupPermissions, (per) => {
+                if (!per || !args.config.match)
+                    return;
+                this.permitted = per[args.config.match];
+            });
+        });
+    }
+}
+export { UeUserGroupPermissionCondition as api };

package/dist/core/conditions/workspace-property-has-value.condition.d.ts

@@ -0,0 +1,7 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from "@umbraco-cms/backoffice/extension-api";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import type { UeWorkspacePropertyHasValueConditionConfig } from "./types.js";
+export declare class UeWorkspacePropertyHasValueCondition extends UmbConditionBase<UeWorkspacePropertyHasValueConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UeWorkspacePropertyHasValueConditionConfig>);
+}

package/dist/core/conditions/workspace-property-has-value.condition.js

@@ -0,0 +1,15 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import { UMB_ENTITY_WORKSPACE_CONTEXT } from "@umbraco-cms/backoffice/workspace";
+const ObserveSymbol = Symbol();
+export class UeWorkspacePropertyHasValueCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_ENTITY_WORKSPACE_CONTEXT, (context) => {
+            if (!this.config?.observablePropertyAlias)
+                return;
+            this.observe(context?.[this.config.observablePropertyAlias], (data) => {
+                this.permitted = data === this.config.value;
+            }, ObserveSymbol);
+        });
+    }
+}

package/dist/core/conditions/workspace-view-active.condition.d.ts

@@ -0,0 +1,8 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from "@umbraco-cms/backoffice/extension-api";
+import { UeWorkspaceViewActiveConditionConfig } from "./types.js";
+export declare class UeWorkspaceViewIsActiveWorkspaceCondition extends UmbConditionBase<UeWorkspaceViewActiveConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UeWorkspaceViewActiveConditionConfig>);
+}
+export { UeWorkspaceViewIsActiveWorkspaceCondition as api };

package/dist/core/conditions/workspace-view-active.condition.js

@@ -0,0 +1,21 @@
+import { UmbConditionBase } from "@umbraco-cms/backoffice/extension-registry";
+import { ENGAGE_VIEW_AWARE_WORKSPACE_CONTEXT } from "../context/index.js";
+export class UeWorkspaceViewIsActiveWorkspaceCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(ENGAGE_VIEW_AWARE_WORKSPACE_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.observe(context.activeView, (activeView) => {
+                if (!activeView)
+                    return;
+                this.permitted =
+                    ((args.config.match !== undefined &&
+                        activeView.endsWith(args.config.match)) ||
+                        args.config.oneOf?.some((x) => activeView.endsWith(x))) ??
+                        false;
+            });
+        });
+    }
+}
+export { UeWorkspaceViewIsActiveWorkspaceCondition as api };

package/dist/core/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const ENGAGE_FEATURE_PERSONALIZATION = "personalization";
+export declare const ENGAGE_FEATURE_ABTESTING = "abTesting";
+export declare const ENGAGE_FEATURE_ANALYTICS = "analytics";
+export declare const ENGAGE_FEATURE_PROFILES = "profiles";
+export declare const ENGAGE_FEATURE_REPORTING = "reporting";
+export declare const ENGAGE_FEATURE_SETTINGS = "settings";
+export declare const SHOW_ANALYTICS = "showAnalytics";
+export declare const ALLOW_ABTESTING = "allowAbTesting";
+export declare const ALLOW_APPLY_PERSONALIZATION = "allowApplyPersonalization";
+export declare const ALLOW_SCORE_PERSONALIZATION = "allowScorePersonalization";

package/dist/core/constants.js

@@ -0,0 +1,10 @@
+export const ENGAGE_FEATURE_PERSONALIZATION = "personalization";
+export const ENGAGE_FEATURE_ABTESTING = "abTesting";
+export const ENGAGE_FEATURE_ANALYTICS = "analytics";
+export const ENGAGE_FEATURE_PROFILES = "profiles";
+export const ENGAGE_FEATURE_REPORTING = "reporting";
+export const ENGAGE_FEATURE_SETTINGS = "settings";
+export const SHOW_ANALYTICS = "showAnalytics";
+export const ALLOW_ABTESTING = "allowAbTesting";
+export const ALLOW_APPLY_PERSONALIZATION = "allowApplyPersonalization";
+export const ALLOW_SCORE_PERSONALIZATION = "allowScorePersonalization";

package/dist/core/context/context/engage-context.d.ts

@@ -0,0 +1,21 @@
+import { UmbContextBase } from "@umbraco-cms/backoffice/class-api";
+import { type Observable } from "@umbraco-cms/backoffice/observable-api";
+import type { UmbControllerHost } from "@umbraco-cms/backoffice/controller-api";
+import { UeLicensedFeaturesMap } from "../../entities.js";
+import { type UeDocumentTypePermissionMap, type UeUserGroupPermissionMap } from "../../entities.js";
+import { type MainSwitchStatusResponseModel, type ConfigurationDtoModel, type PackageStatusResultModel, type DocumentTypePermissionDtoModel } from "../../../generated/index.js";
+export declare class UeContext extends UmbContextBase {
+    #private;
+    configuration: Observable<ConfigurationDtoModel | undefined>;
+    packageStatus: Observable<PackageStatusResultModel | undefined>;
+    licensedFeatures: Observable<UeLicensedFeaturesMap>;
+    userGroupPermissions: Observable<UeUserGroupPermissionMap | undefined>;
+    documentTypePermissions: Observable<DocumentTypePermissionDtoModel[]>;
+    mainSwitch: Observable<MainSwitchStatusResponseModel | undefined>;
+    constructor(host: UmbControllerHost);
+    getLastGenerated(): Promise<string>;
+    disableEngage(): Promise<void>;
+    enableEngage(): Promise<void>;
+    getDocumentTypePermission(name?: string, permission?: string & keyof UeDocumentTypePermissionMap): boolean;
+}
+export default UeContext;