@umbraco-cms/backoffice 14.0.0-9cc9c792 → 14.0.0-a0074b6e

package/dist-cms/packages/core/workspace/variant-context/invariant-workspace-variant-context.js

@@ -0,0 +1,48 @@
+import { UmbBaseController } from "../../../../libs/controller-api/index.js";
+import { UmbObjectState } from "../../../../libs/observable-api/index.js";
+import { UmbVariantId } from "../../variant/index.js";
+import { UMB_VARIANT_CONTEXT } from "../index.js";
+export class UmbInvariantWorkspaceVariantContext extends UmbBaseController {
+    #currentVariant;
+    // default data:
+    getVariantId() {
+        return UmbVariantId.CreateInvariant();
+    }
+    getType() {
+        return this._workspace.getEntityType();
+    }
+    getUnique() {
+        return this._workspace.getEntityId();
+    }
+    getName() {
+        return this._workspace.getName();
+    }
+    setName(name) {
+        this._workspace.setName(name);
+    }
+    constructor(host, workspace) {
+        // The controller alias, is a very generic name cause we want only one of these for this controller host.
+        super(host, 'variantContext');
+        this.#currentVariant = new UmbObjectState(undefined);
+        this.currentVariant = this.#currentVariant.asObservable();
+        this.name = this.#currentVariant.asObservablePart((x) => x?.name);
+        this.culture = this.#currentVariant.asObservablePart((x) => x?.culture);
+        this.segment = this.#currentVariant.asObservablePart((x) => x?.segment);
+        this._workspace = workspace;
+        this.provideContext(UMB_VARIANT_CONTEXT, this);
+    }
+    /**
+     * TODO: Write proper JSDocs here.
+     * Ideally do not use these methods, its better to communicate directly with the workspace, but if you do not know the property variant id, then this will figure it out for you. So good for externals to set or get values of a property.
+     */
+    async propertyValueByAlias(propertyAlias) {
+        return this._workspace.propertyValueByAlias(propertyAlias);
+    }
+    /**
+     * TODO: Write proper JSDocs here.
+     * Ideally do not use these methods, its better to communicate directly with the workspace, but if you do not know the property variant id, then this will figure it out for you. So good for externals to set or get values of a property.
+     */
+    async setPropertyValue(propertyAlias, value) {
+        return this._workspace.setPropertyValue(propertyAlias, value);
+    }
+}

package/dist-cms/packages/core/workspace/variant-context/nameable-variant-context.interface.d.ts

@@ -0,0 +1,7 @@
+import { UmbVariantContext } from "./variant-context.interface.js";
+/**
+ * A variant context with ability to set the name of it.
+*/
+export interface UmbNameableVariantContext extends UmbVariantContext {
+    setName(name: string): void;
+}

package/dist-cms/packages/core/workspace/variant-context/nameable-variant-context.token.d.ts

@@ -0,0 +1,5 @@
+import { type UmbVariantContext } from "./variant-context.interface.js";
+import { UmbNameableVariantContext } from "./nameable-variant-context.interface.js";
+import { UmbContextToken } from "../../../../libs/context-api/index.js";
+export declare const isNameablePropertySetContext: (context: UmbVariantContext) => context is UmbNameableVariantContext;
+export declare const UMB_NAMEABLE_VARIANT_CONTEXT: UmbContextToken<UmbVariantContext, UmbNameableVariantContext>;

package/dist-cms/packages/core/workspace/variant-context/nameable-variant-context.token.js

@@ -0,0 +1,3 @@
+import { UmbContextToken } from "../../../../libs/context-api/index.js";
+export const isNameablePropertySetContext = (context) => 'setName' in context;
+export const UMB_NAMEABLE_VARIANT_CONTEXT = new UmbContextToken("UmbVariantContext", isNameablePropertySetContext);

package/dist-cms/packages/core/workspace/variant-context/variant-context.interface.d.ts

@@ -0,0 +1,26 @@
+import type { UmbVariantId } from "../../variant/variant-id.class.js";
+import type { Observable } from "../../../../external/rxjs/index.js";
+/**
+ * A variant context, represents a set of properties.
+ * This can take form as many, so to list a few:
+ * - A specific variant of content
+ * - Content that does not vary
+ * - A block.
+ * - A DataType configuration.
+ *
+ * The base type of this holds a Name and some Properties.
+ * Some might be enriches with Variant Info, like culture and segment.
+ * Others might have saved publishing status.
+ * Also setting the name is an additional feature.
+ */
+export interface UmbVariantContext {
+    getType(): string;
+    getUnique(): string | undefined;
+    getVariantId: (() => UmbVariantId);
+    getName(): string | undefined;
+    readonly name: Observable<string | undefined>;
+    destroy(): void;
+    propertyVariantId?: ((propertyAlias: string) => Promise<Observable<UmbVariantId | undefined>>);
+    propertyValueByAlias<ReturnType = unknown>(propertyAlias: string): Promise<Observable<ReturnType | undefined>>;
+    setPropertyValue(propertyAlias: string, value: unknown): Promise<void>;
+}

package/dist-cms/packages/core/workspace/variant-context/variant-context.token.d.ts

@@ -0,0 +1,3 @@
+import { type UmbVariantContext } from "./variant-context.interface.js";
+import { UmbContextToken } from "../../../../libs/context-api/index.js";
+export declare const UMB_VARIANT_CONTEXT: UmbContextToken<UmbVariantContext, UmbVariantContext>;

package/dist-cms/packages/core/workspace/variant-context/variant-context.token.js

@@ -0,0 +1,2 @@
+import { UmbContextToken } from "../../../../libs/context-api/index.js";
+export const UMB_VARIANT_CONTEXT = new UmbContextToken("UmbVariantContext");

package/dist-cms/packages/core/workspace/workspace-context/index.d.ts

@@ -1,7 +1,10 @@
 export * from './entity-manager-controller.js';
-export * from './workspace-context.js';
+export * from './property-structure-workspace-context.interface.js';
+export * from './publishable-workspace-context.interface.js';
+export * from './saveable-workspace-context.interface.js';
+export * from './variant-workspace-context.token.js';
 export * from './workspace-context.interface.js';
-export * from './workspace-entity-context.interface.js';
-export * from './workspace-invariantable-entity-context.interface.js';
-export * from './workspace-variable-entity-context.interface.js';
+export * from './workspace-context.js';
 export * from './workspace-context.token.js';
+export * from './workspace-invariantable-context.interface.js';
+export * from './workspace-variantable-context.interface.js';

package/dist-cms/packages/core/workspace/workspace-context/index.js

@@ -1,7 +1,10 @@
 export * from './entity-manager-controller.js';
-export * from './workspace-context.js';
+export * from './property-structure-workspace-context.interface.js';
+export * from './publishable-workspace-context.interface.js';
+export * from './saveable-workspace-context.interface.js';
+export * from './variant-workspace-context.token.js';
 export * from './workspace-context.interface.js';
-export * from './workspace-entity-context.interface.js';
-export * from './workspace-invariantable-entity-context.interface.js';
-export * from './workspace-variable-entity-context.interface.js';
+export * from './workspace-context.js';
 export * from './workspace-context.token.js';
+export * from './workspace-invariantable-context.interface.js';
+export * from './workspace-variantable-context.interface.js';

package/dist-cms/packages/core/workspace/workspace-context/property-structure-workspace-context.interface.d.ts

@@ -0,0 +1,6 @@
+import type { UmbWorkspaceContextInterface } from './workspace-context.interface.js';
+import { Observable } from '../../../../external/rxjs/index.js';
+import type { ValueModelBaseModel } from '../../../../external/backend-api/index.js';
+export interface UmbPropertyStructureWorkspaceContextInterface<EntityType = unknown> extends UmbWorkspaceContextInterface<EntityType> {
+    propertyStructureById(id: string): Promise<Observable<ValueModelBaseModel | undefined>>;
+}

package/dist-cms/packages/core/workspace/workspace-context/publishable-workspace-context.interface.d.ts

@@ -0,0 +1,4 @@
+import type { UmbSaveableWorkspaceContextInterface } from './saveable-workspace-context.interface.js';
+export interface UmbPublishableWorkspaceContextInterface<EntityType = unknown> extends UmbSaveableWorkspaceContextInterface<EntityType> {
+    publish(): Promise<void>;
+}

package/dist-cms/packages/core/workspace/workspace-context/publishable-workspace-context.interface.js

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

package/dist-cms/packages/core/workspace/workspace-context/saveable-workspace-context.interface.d.ts

@@ -0,0 +1,4 @@
+import type { UmbWorkspaceContextInterface } from './workspace-context.interface.js';
+export interface UmbSaveableWorkspaceContextInterface<EntityType = unknown> extends UmbWorkspaceContextInterface<EntityType> {
+    save(): Promise<void>;
+}

package/dist-cms/packages/core/workspace/workspace-context/saveable-workspace-context.interface.js

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

package/dist-cms/packages/core/workspace/workspace-context/variant-workspace-context.token.d.ts

@@ -0,0 +1,5 @@
+import type { UmbWorkspaceContextInterface } from './workspace-context.interface.js';
+import type { UmbVariantableWorkspaceContextInterface } from './workspace-variantable-context.interface.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import type { UmbEntityBase } from '../../../../shared/models/index.js';
+export declare const UMB_VARIANT_WORKSPACE_CONTEXT_TOKEN: UmbContextToken<UmbWorkspaceContextInterface<UmbEntityBase>, UmbVariantableWorkspaceContextInterface<UmbEntityBase>>;

package/dist-cms/packages/core/workspace/workspace-context/variant-workspace-context.token.js

@@ -0,0 +1,2 @@
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+export const UMB_VARIANT_WORKSPACE_CONTEXT_TOKEN = new UmbContextToken('UmbWorkspaceContext', (context) => 'variants' in context);

package/dist-cms/packages/core/workspace/workspace-context/workspace-context.d.ts

@@ -1,8 +1,8 @@
-import { UmbEntityWorkspaceContextInterface } from './workspace-entity-context.interface.js';
+import { UmbSaveableWorkspaceContextInterface } from './saveable-workspace-context.interface.js';
 import { UmbBaseController, UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
 import type { UmbEntityBase } from '../../../../shared/models/index.js';
 import { UmbModalContext } from '../../modal/index.js';
-export declare abstract class UmbWorkspaceContext<RepositoryType, EntityType extends UmbEntityBase> extends UmbBaseController implements UmbEntityWorkspaceContextInterface<EntityType> {
+export declare abstract class UmbWorkspaceContext<RepositoryType, EntityType extends UmbEntityBase> extends UmbBaseController implements UmbSaveableWorkspaceContextInterface<EntityType> {
     #private;
     readonly host: UmbControllerHostElement;
     readonly workspaceAlias: string;

package/dist-cms/packages/core/workspace/workspace-context/workspace-context.interface.d.ts

@@ -1,14 +1,12 @@
 import { Observable } from '../../../../external/rxjs/index.js';
 export interface UmbWorkspaceContextInterface<DataType = unknown> {
+    destroy(): void;
     workspaceAlias: string;
-    repository: any;
+    save(): Promise<void>;
+    setValidationErrors?(errorMap: any): void;
+    getEntityId(): string | undefined;
+    getEntityType(): string;
     isNew: Observable<boolean | undefined>;
     getIsNew(): boolean | undefined;
     setIsNew(value: boolean): void;
-    getEntityId(): string | undefined;
-    getEntityType(): string;
-    getData(): DataType | undefined;
-    save(): Promise<void>;
-    destroy(): void;
-    setValidationErrors?(errorMap: any): void;
 }

package/dist-cms/packages/core/workspace/workspace-context/workspace-invariantable-context.interface.d.ts

@@ -0,0 +1,13 @@
+import { UmbVariantId } from '../../variant/variant-id.class.js';
+import { UmbVariantContext } from '../variant-context/variant-context.interface.js';
+import type { UmbSaveableWorkspaceContextInterface } from './saveable-workspace-context.interface.js';
+import { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import type { Observable } from '../../../../external/rxjs/index.js';
+export interface UmbInvariantableWorkspaceContextInterface<T = unknown> extends UmbSaveableWorkspaceContextInterface<T> {
+    getName(): string | undefined;
+    setName(name: string): void;
+    propertyValueByAlias<ReturnType = unknown>(alias: string): Promise<Observable<ReturnType | undefined>>;
+    getPropertyValue<ReturnType = unknown>(alias: string): ReturnType;
+    setPropertyValue(alias: string, value: unknown): Promise<void>;
+    createVariantContext(host: UmbControllerHost, variantId?: UmbVariantId): UmbVariantContext;
+}

package/dist-cms/packages/core/workspace/workspace-context/workspace-invariantable-context.interface.js

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

package/dist-cms/packages/core/workspace/workspace-context/workspace-variantable-context.interface.d.ts

@@ -0,0 +1,18 @@
+import type { UmbWorkspaceSplitViewManager } from '../workspace-split-view-manager.class.js';
+import { UmbVariantContext } from '../variant-context/variant-context.interface.js';
+import type { UmbSaveableWorkspaceContextInterface } from './saveable-workspace-context.interface.js';
+import type { Observable } from '../../../../external/rxjs/index.js';
+import type { UmbVariantId } from '../../variant/index.js';
+import type { VariantResponseModelBaseModel } from '../../../../external/backend-api/index.js';
+import { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export interface UmbVariantableWorkspaceContextInterface<EntityType = unknown> extends UmbSaveableWorkspaceContextInterface<EntityType> {
+    getName(variantId?: UmbVariantId): string | undefined;
+    setName(name: string, variantId?: UmbVariantId): void;
+    variants: Observable<Array<VariantResponseModelBaseModel>>;
+    splitView: UmbWorkspaceSplitViewManager;
+    getVariant(variantId: UmbVariantId): VariantResponseModelBaseModel | undefined;
+    propertyValueByAlias<ReturnValue = unknown>(alias: string, variantId?: UmbVariantId): Promise<Observable<ReturnValue | undefined>>;
+    getPropertyValue<ReturnValue = unknown>(alias: string, variantId?: UmbVariantId): ReturnValue | undefined;
+    setPropertyValue(alias: string, value: unknown, variantId?: UmbVariantId): Promise<void>;
+    createVariantContext(host: UmbControllerHost, variantId?: UmbVariantId): UmbVariantContext;
+}

package/dist-cms/packages/core/workspace/workspace-context/workspace-variantable-context.interface.js

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

package/dist-cms/packages/core/workspace/workspace-editor/workspace-editor.element.js

@@ -23,7 +23,7 @@ import { componentHasManifestProperty } from '../../../../shared/utils/index.js'
  * @class UmbWorkspaceLayout
  * @extends {UmbLitElement}
  */
-// TODO: stop naming this something with layout. as its not just an layout. it hooks up with extensions.
+// TODO: This element has a bug in the tabs. After the url changes - for example a new entity/file is chosen in the tree and loaded to the workspace the links in the tabs still point to the previous url and therefore views do not change correctly 
 export let UmbWorkspaceEditorElement = class UmbWorkspaceEditorElement extends UmbLitElement {
     constructor() {
         super();

package/dist-cms/packages/core/workspace/workspace-property/workspace-property.context.d.ts

@@ -1,18 +1,18 @@
 import { UmbPropertyEditorExtensionElement } from '../../extension-registry/interfaces/property-editor-ui-extension-element.interface.js';
 import { type WorkspacePropertyData } from '../types/workspace-property-data.type.js';
 import { UmbVariantId } from '../../variant/index.js';
-import type { UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
+import { UmbBaseController, type UmbControllerHostElement } from '../../../../libs/controller-api/index.js';
 import { UmbContextToken } from '../../../../libs/context-api/index.js';
-import { UmbDataTypeConfigCollection } from '../../components/index.js';
-export declare class UmbWorkspacePropertyContext<ValueType = any> {
+import { UmbPropertyEditorConfigCollection } from '../../property-editor/index.js';
+export declare class UmbWorkspacePropertyContext<ValueType = any> extends UmbBaseController {
     #private;
     private _providerController;
     readonly alias: import("rxjs").Observable<string | undefined>;
     readonly label: import("rxjs").Observable<string | undefined>;
     readonly description: import("rxjs").Observable<string | undefined>;
     readonly value: import("rxjs").Observable<ValueType | null | undefined>;
-    readonly configValues: import("rxjs").Observable<import("../../index.js").UmbDataTypeConfig | undefined>;
-    readonly config: import("rxjs").Observable<UmbDataTypeConfigCollection | undefined>;
+    readonly configValues: import("rxjs").Observable<import("../../property-editor/index.js").UmbPropertyEditorConfig | undefined>;
+    readonly config: import("rxjs").Observable<UmbPropertyEditorConfigCollection | undefined>;
     private _editor;
     readonly editor: import("rxjs").Observable<UmbPropertyEditorExtensionElement | undefined>;
     setEditor(editor: UmbPropertyEditorExtensionElement | undefined): void;
@@ -20,15 +20,15 @@ export declare class UmbWorkspacePropertyContext<ValueType = any> {
     readonly variantId: import("rxjs").Observable<UmbVariantId | undefined>;
     private _variantDifference;
     readonly variantDifference: import("rxjs").Observable<string | undefined>;
-    private _workspaceContext?;
-    private _workspaceVariantConsumer?;
     constructor(host: UmbControllerHostElement);
+    private _observePropertyVariant?;
+    private _observePropertyValue?;
+    private _observeProperty;
     private _generateVariantDifferenceString;
     setAlias(alias: WorkspacePropertyData<ValueType>['alias']): void;
     setLabel(label: WorkspacePropertyData<ValueType>['label']): void;
     setDescription(description: WorkspacePropertyData<ValueType>['description']): void;
     setValue(value: WorkspacePropertyData<ValueType>['value']): void;
-    changeValue(value: WorkspacePropertyData<ValueType>['value']): void;
     setConfig(config: WorkspacePropertyData<ValueType>['config'] | undefined): void;
     setVariantId(variantId: UmbVariantId | undefined): void;
     getVariantId(): UmbVariantId | undefined;

package/dist-cms/packages/core/workspace/workspace-property/workspace-property.context.js

@@ -1,9 +1,9 @@
-import { UMB_WORKSPACE_VARIANT_CONTEXT_TOKEN, UMB_WORKSPACE_CONTEXT } from '../index.js';
-import { UmbClassState, UmbObjectState, UmbStringState, UmbObserverController, UmbBasicState, } from '../../../../libs/observable-api/index.js';
-import { UmbContextConsumerController, UmbContextProviderController, UmbContextToken, } from '../../../../libs/context-api/index.js';
-import { UmbDataTypeConfigCollection } from '../../components/index.js';
-export class UmbWorkspacePropertyContext {
-    #host;
+import { UMB_VARIANT_CONTEXT } from '../index.js';
+import { UmbBaseController } from '../../../../libs/controller-api/index.js';
+import { UmbClassState, UmbObjectState, UmbStringState, UmbBasicState, } from '../../../../libs/observable-api/index.js';
+import { UmbContextProviderController, UmbContextToken, } from '../../../../libs/context-api/index.js';
+import { UmbPropertyEditorConfigCollection } from '../../property-editor/index.js';
+export class UmbWorkspacePropertyContext extends UmbBaseController {
     #data;
     #configCollection;
     setEditor(editor) {
@@ -12,9 +12,11 @@ export class UmbWorkspacePropertyContext {
     getEditor() {
         return this._editor.getValue();
     }
-    #workspaceVariantId;
+    // property variant ID:
     #variantId;
+    #variantContext;
     constructor(host) {
+        super(host);
         this.#data = new UmbObjectState({});
         this.alias = this.#data.asObservablePart((data) => data.alias);
         this.label = this.#data.asObservablePart((data) => data.label);
@@ -25,36 +27,53 @@ export class UmbWorkspacePropertyContext {
         this.config = this.#configCollection.asObservable();
         this._editor = new UmbBasicState(undefined);
         this.editor = this._editor.asObservable();
+        // property variant ID:
         this.#variantId = new UmbClassState(undefined);
         this.variantId = this.#variantId.asObservable();
         this._variantDifference = new UmbStringState(undefined);
         this.variantDifference = this._variantDifference.asObservable();
-        this.#host = host;
-        new UmbContextConsumerController(host, UMB_WORKSPACE_CONTEXT, (workspaceContext) => {
-            this._workspaceContext = workspaceContext;
+        this.consumeContext(UMB_VARIANT_CONTEXT, (variantContext) => {
+            this.#variantContext = variantContext;
+            this._generateVariantDifferenceString();
+            this._observeProperty();
+        });
+        this.observe(this.alias, () => {
+            this._observeProperty();
         });
         this._providerController = new UmbContextProviderController(host, UMB_WORKSPACE_PROPERTY_CONTEXT_TOKEN, this);
-        this.configValues.subscribe((configValues) => {
-            this.#configCollection.next(configValues ? new UmbDataTypeConfigCollection(configValues) : undefined);
+        this.observe(this.configValues, (configValues) => {
+            this.#configCollection.next(configValues ? new UmbPropertyEditorConfigCollection(configValues) : undefined);
         });
-        this.variantId.subscribe((propertyVariantId) => {
-            if (propertyVariantId) {
-                if (!this._workspaceVariantConsumer) {
-                    this._workspaceVariantConsumer = new UmbContextConsumerController(this.#host, UMB_WORKSPACE_VARIANT_CONTEXT_TOKEN, (workspaceVariantContext) => {
-                        new UmbObserverController(this.#host, workspaceVariantContext.variantId, (workspaceVariantId) => {
-                            this.#workspaceVariantId = workspaceVariantId;
-                            this._generateVariantDifferenceString();
-                        });
-                    });
-                }
-                else {
-                    this._generateVariantDifferenceString();
-                }
-            }
+        this.observe(this.variantId, () => {
+            this._generateVariantDifferenceString();
         });
     }
+    async _observeProperty() {
+        const alias = this.#data.getValue().alias;
+        if (!this.#variantContext || !alias)
+            return;
+        const variantIdSubject = await this.#variantContext.propertyVariantId?.(alias) ?? undefined;
+        this._observePropertyVariant?.destroy();
+        if (variantIdSubject) {
+            this._observePropertyVariant = this.observe(variantIdSubject, (variantId) => {
+                this.#variantId.next(variantId);
+            });
+        }
+        // TODO: Verify if we need to optimize runtime by parsing the propertyVariantID, cause this method retrieves it again:
+        const subject = await this.#variantContext.propertyValueByAlias(alias);
+        this._observePropertyValue?.destroy();
+        if (subject) {
+            this._observePropertyValue = this.observe(subject, (value) => {
+                // Note: Do not try to compare new / old value, as it can of any type. We trust the UmbObjectState in doing such.
+                this.#data.update({ value });
+            });
+        }
+    }
     _generateVariantDifferenceString() {
-        this._variantDifference.next(this.#workspaceVariantId ? this.#variantId.getValue()?.toDifferencesString(this.#workspaceVariantId) : '');
+        if (!this.#variantContext)
+            return;
+        const contextVariantId = this.#variantContext.getVariantId?.() ?? undefined;
+        this._variantDifference.next(contextVariantId ? this.#variantId.getValue()?.toDifferencesString(contextVariantId) : '');
     }
     setAlias(alias) {
         this.#data.update({ alias });
@@ -66,15 +85,10 @@ export class UmbWorkspacePropertyContext {
         this.#data.update({ description });
     }
     setValue(value) {
-        // Note: Do not try to compare new / old value, as it can of any type. We trust the UmbObjectState in doing such.
-        this.#data.update({ value });
-    }
-    changeValue(value) {
-        this.setValue(value);
         const alias = this.#data.getValue().alias;
-        if (alias) {
-            this._workspaceContext?.setPropertyValue(alias, value, this.#variantId.getValue());
-        }
+        if (!this.#variantContext || !alias)
+            return;
+        this.#variantContext?.setPropertyValue(alias, value);
     }
     setConfig(config) {
         this.#data.update({ config });

package/dist-cms/packages/core/workspace/workspace-property/workspace-property.element.d.ts

@@ -1,5 +1,4 @@
-import { type UmbDataTypeConfig } from '../../property-editor/index.js';
-import { UmbVariantId } from '../../variant/index.js';
+import { type UmbPropertyEditorConfig } from '../../property-editor/index.js';
 import { UmbLitElement } from '../../../../shared/lit-element/index.js';
 /**
  *  @element umb-workspace-property
@@ -38,14 +37,6 @@ export declare class UmbWorkspacePropertyElement extends UmbLitElement {
      */
     private _propertyEditorUiAlias;
     set propertyEditorUiAlias(value: string);
-    /**
-     * Property Value, this is the value stored in the property.
-     * @public
-     * @type {unknown}
-     * @attr
-     * @default undefined
-     */
-    set value(value: unknown);
     /**
      * Config. Configuration to pass to the Property Editor UI. This is also the configuration data stored on the Data Type.
      * @public
@@ -53,15 +44,7 @@ export declare class UmbWorkspacePropertyElement extends UmbLitElement {
      * @attr
      * @default ''
      */
-    set config(value: UmbDataTypeConfig | undefined);
-    /**
-     * PropertyVariantId. A Variant ID to identify which variant its value is stored on.
-     * @public
-     * @type {UmbVariantId}
-     * @attr
-     * @default null
-     */
-    set propertyVariantId(value: UmbVariantId | undefined);
+    set config(value: UmbPropertyEditorConfig | undefined);
     private _variantDifference?;
     private _element?;
     private _value?;

package/dist-cms/packages/core/workspace/workspace-property/workspace-property.element.js

@@ -50,16 +50,6 @@ export let UmbWorkspacePropertyElement = class UmbWorkspacePropertyElement exten
         this._propertyEditorUiAlias = value;
         this._observePropertyEditorUI();
     }
-    /**
-     * Property Value, this is the value stored in the property.
-     * @public
-     * @type {unknown}
-     * @attr
-     * @default undefined
-     */
-    set value(value) {
-        this._propertyContext.setValue(value);
-    }
     /**
      * Config. Configuration to pass to the Property Editor UI. This is also the configuration data stored on the Data Type.
      * @public
@@ -70,17 +60,6 @@ export let UmbWorkspacePropertyElement = class UmbWorkspacePropertyElement exten
     set config(value) {
         this._propertyContext.setConfig(value);
     }
-    /**
-     * PropertyVariantId. A Variant ID to identify which variant its value is stored on.
-     * @public
-     * @type {UmbVariantId}
-     * @attr
-     * @default null
-     */
-    set propertyVariantId(value) {
-        this._propertyContext.setVariantId(value);
-        //this._variantDisplayName = value?.toString();
-    }
     constructor() {
         super();
         /**
@@ -95,7 +74,7 @@ export let UmbWorkspacePropertyElement = class UmbWorkspacePropertyElement exten
         this._onPropertyEditorChange = (e) => {
             const target = e.composedPath()[0];
             //this.value = target.value; // Sets value in context.
-            this._propertyContext.changeValue(target.value);
+            this._propertyContext.setValue(target.value);
             e.stopPropagation();
         };
         this.observe(this._propertyContext.alias, (alias) => {
@@ -170,8 +149,8 @@ export let UmbWorkspacePropertyElement = class UmbWorkspacePropertyElement exten
             ? html `<umb-property-action-menu
 					slot="property-action-menu"
 					id="property-action-menu"
-					.propertyEditorUiAlias="${this._propertyEditorUiAlias}"
-					.value="${this._value}"></umb-property-action-menu>`
+					.propertyEditorUiAlias=${this._propertyEditorUiAlias}
+					.value=${this._value}></umb-property-action-menu>`
             : ''}`;
     }
     static { this.styles = [
@@ -213,15 +192,9 @@ __decorate([
 __decorate([
     property({ type: String, attribute: 'property-editor-ui-alias' })
 ], UmbWorkspacePropertyElement.prototype, "propertyEditorUiAlias", null);
-__decorate([
-    property({ attribute: false })
-], UmbWorkspacePropertyElement.prototype, "value", null);
 __decorate([
     property({ type: Array, attribute: false })
 ], UmbWorkspacePropertyElement.prototype, "config", null);
-__decorate([
-    property({ type: Object, attribute: false })
-], UmbWorkspacePropertyElement.prototype, "propertyVariantId", null);
 __decorate([
     state()
 ], UmbWorkspacePropertyElement.prototype, "_variantDifference", void 0);

package/dist-cms/packages/core/workspace/workspace-split-view/index.d.ts

@@ -0,0 +1,2 @@
+export * from './workspace-split-view.context.js';
+export * from './workspace-split-view.element.js';

package/dist-cms/packages/core/workspace/workspace-split-view/index.js

@@ -0,0 +1,2 @@
+export * from './workspace-split-view.context.js';
+export * from './workspace-split-view.element.js';

package/dist-cms/packages/core/workspace/workspace-split-view/workspace-split-view.context.d.ts

@@ -0,0 +1,16 @@
+import { UmbVariantId } from '../../variant/index.js';
+import { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { UmbBaseController, UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export declare class UmbWorkspaceSplitViewContext extends UmbBaseController {
+    #private;
+    getWorkspaceContext(): import("../index.js").UmbVariantableWorkspaceContextInterface<import("../../../../shared/models/index.js").UmbEntityBase> | undefined;
+    index: import("rxjs").Observable<number | undefined>;
+    constructor(host: UmbControllerHost);
+    private _observeVariant;
+    switchVariant(variant: UmbVariantId): void;
+    closeSplitView(): void;
+    openSplitView(variant: UmbVariantId): void;
+    getSplitViewIndex(): number | undefined;
+    setSplitViewIndex(index: number): void;
+}
+export declare const UMB_WORKSPACE_SPLIT_VIEW_CONTEXT: UmbContextToken<UmbWorkspaceSplitViewContext, UmbWorkspaceSplitViewContext>;

package/dist-cms/packages/core/workspace/workspace-split-view/workspace-split-view.context.js

@@ -0,0 +1,66 @@
+import { UMB_VARIANT_WORKSPACE_CONTEXT_TOKEN } from '../index.js';
+import { UmbVariantId } from '../../variant/index.js';
+import { UmbContextToken, } from '../../../../libs/context-api/index.js';
+import { UmbBaseController } from '../../../../libs/controller-api/index.js';
+import { UmbNumberState, } from '../../../../libs/observable-api/index.js';
+export class UmbWorkspaceSplitViewContext extends UmbBaseController {
+    #workspaceContext;
+    getWorkspaceContext() {
+        return this.#workspaceContext;
+    }
+    #variantContext;
+    #index;
+    //#variantId = new UmbClassState<UmbVariantId | undefined>(undefined);
+    //variantId = this.#variantId.asObservable();
+    constructor(host) {
+        super(host);
+        this.#index = new UmbNumberState(undefined);
+        this.index = this.#index.asObservable();
+        this.consumeContext(UMB_VARIANT_WORKSPACE_CONTEXT_TOKEN, (context) => {
+            this.#workspaceContext = context;
+            this._observeVariant();
+        });
+        this.observe(this.#index, () => {
+            this._observeVariant();
+        });
+        this.provideContext(UMB_WORKSPACE_SPLIT_VIEW_CONTEXT, this);
+    }
+    _observeVariant() {
+        if (!this.#workspaceContext)
+            return;
+        const index = this.#index.getValue();
+        if (index === undefined)
+            return;
+        // TODO: Should splitView be put into its own context?... a split view manager context?   one which might have a reference to the workspace context, so we still can ask that about how to create the variant context.
+        this.observe(this.#workspaceContext.splitView.activeVariantByIndex(index), async (activeVariantInfo) => {
+            if (!activeVariantInfo)
+                return;
+            // TODO: Ask workspace context to create the specific variant context.
+            this.#variantContext?.destroy();
+            const variantId = UmbVariantId.Create(activeVariantInfo);
+            this.#variantContext = this.#workspaceContext?.createVariantContext(this, variantId);
+        }, '_observeActiveVariant');
+    }
+    switchVariant(variant) {
+        const index = this.#index.value;
+        if (index === undefined)
+            return;
+        this.#workspaceContext?.splitView.switchVariant(index, variant);
+    }
+    closeSplitView() {
+        const index = this.#index.value;
+        if (index === undefined)
+            return;
+        this.#workspaceContext?.splitView.closeSplitView(index);
+    }
+    openSplitView(variant) {
+        this.#workspaceContext?.splitView.openSplitView(variant);
+    }
+    getSplitViewIndex() {
+        return this.#index.getValue();
+    }
+    setSplitViewIndex(index) {
+        this.#index.next(index);
+    }
+}
+export const UMB_WORKSPACE_SPLIT_VIEW_CONTEXT = new UmbContextToken('umbWorkspaceSplitViewContext');