@umbraco-cms/backoffice 14.2.0 → 14.3.0

package/dist-cms/packages/core/workspace/components/workspace-action-menu-item/workspace-action-menu-item-base.controller.js

@@ -1,7 +1,6 @@
 import { UmbActionBase } from '../../../action/index.js';
 /**
  * Base class for an workspace action.
- * @export
  * @abstract
  * @class UmbWorkspaceActionMenuItemBase
  * @augments {UmbActionBase}

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

@@ -8,7 +8,6 @@ import { UmbLitElement } from '../../../lit-element/index.js';
  * @slot footer - Slot for workspace footer
  * @slot actions - Slot for workspace footer actions
  * @slot - slot for main content
- * @export
  * @class UmbWorkspaceEditor
  * @augments {UmbLitElement}
  */

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

@@ -18,11 +18,9 @@ import { UmbTextStyles } from '../../../style/index.js';
  * @slot footer - Slot for workspace footer
  * @slot actions - Slot for workspace footer actions
  * @slot - slot for main content
- * @export
  * @class UmbWorkspaceEditor
  * @augments {UmbLitElement}
  */
-// 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
 let UmbWorkspaceEditorElement = class UmbWorkspaceEditorElement extends UmbLitElement {
     constructor() {
         super();

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

@@ -5,7 +5,6 @@ import type { UmbModalContext } from '../../../modal/index.js';
  * @description Uses the alias to insert extensions that targets this workspace-alias.
  * @slot - Slot for workspace footer items
  * @slot actions - Slot for workspace actions
- * @export
  * @class UmbWorkspaceFooterLayout
  * @augments {UmbLitElement}
  */

package/dist-cms/packages/core/workspace/components/workspace-footer/workspace-footer.element.js

@@ -12,6 +12,7 @@ import { UMB_MODAL_CONTEXT } from '../../../modal/index.js';
 /**
  *
  * @param manifest
+ * @returns
  */
 function ExtensionApiArgsMethod(manifest) {
     return [{ meta: manifest.meta }];
@@ -21,7 +22,6 @@ function ExtensionApiArgsMethod(manifest) {
  * @description Uses the alias to insert extensions that targets this workspace-alias.
  * @slot - Slot for workspace footer items
  * @slot actions - Slot for workspace actions
- * @export
  * @class UmbWorkspaceFooterLayout
  * @augments {UmbLitElement}
  */

package/dist-cms/packages/core/workspace/components/workspace-split-view/workspace-split-view-variant-selector.element.d.ts

@@ -1,18 +1,21 @@
 import type { ActiveVariant } from '../../controllers/index.js';
+import { nothing } from '../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../lit-element/index.js';
 declare const elementName = "umb-workspace-split-view-variant-selector";
 export declare class UmbWorkspaceSplitViewVariantSelectorElement extends UmbLitElement {
     #private;
     private _popoverElement?;
-    private _variants;
+    private _variantOptions;
+    private _readOnlyStates;
     _activeVariants: Array<ActiveVariant>;
     _activeVariantsCultures: string[];
     private _name?;
-    private _variantDisplayName;
-    private _variantTitleName;
+    private _activeVariant?;
+    private _variantId?;
     private _variantSelectorOpen;
+    private _readOnlyCultures;
     constructor();
-    render(): import("lit-html").TemplateResult<1>;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
     static styles: import("@lit/reactive-element/css-tag.js").CSSResult[];
 }
 declare global {

package/dist-cms/packages/core/workspace/components/workspace-split-view/workspace-split-view-variant-selector.element.js

@@ -6,29 +6,43 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { UMB_WORKSPACE_SPLIT_VIEW_CONTEXT } from './workspace-split-view.context.js';
 import { UUIInputEvent, } from '../../../../../external/uui/index.js';
-import { css, html, nothing, customElement, state, query } from '../../../../../external/lit/index.js';
+import { css, html, nothing, customElement, state, query, ifDefined } from '../../../../../external/lit/index.js';
 import { DocumentVariantStateModel } from '../../../../../external/backend-api/index.js';
 import { UmbVariantId } from '../../../variant/index.js';
 import { UMB_PROPERTY_DATASET_CONTEXT, isNameablePropertyDatasetContext } from '../../../property/index.js';
 import { UmbLitElement, umbFocus } from '../../../lit-element/index.js';
 import { UmbTextStyles } from '../../../style/index.js';
+import { UmbDataPathVariantQuery, umbBindToValidation } from '../../../validation/index.js';
 const elementName = 'umb-workspace-split-view-variant-selector';
 let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVariantSelectorElement extends UmbLitElement {
     #splitViewContext;
     #datasetContext;
+    #publishStateLocalizationMap;
     constructor() {
         super();
-        this._variants = [];
+        this._variantOptions = [];
+        this._readOnlyStates = [];
         // TODO: Stop using document context specific ActiveVariant type.
         this._activeVariants = [];
         this._activeVariantsCultures = [];
-        this._variantDisplayName = '';
-        this._variantTitleName = '';
         this._variantSelectorOpen = false;
+        this._readOnlyCultures = [];
+        this.#publishStateLocalizationMap = {
+            [DocumentVariantStateModel.DRAFT]: 'content_unpublished',
+            [DocumentVariantStateModel.PUBLISHED]: 'content_published',
+            [DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES]: 'content_publishedPendingChanges',
+            [DocumentVariantStateModel.NOT_CREATED]: 'content_notCreated',
+        };
         this.consumeContext(UMB_WORKSPACE_SPLIT_VIEW_CONTEXT, (instance) => {
             this.#splitViewContext = instance;
-            this.#observeVariants();
-            this.#observeActiveVariants();
+            // NOTICE: This is dirty (the TypeScript casting), we can only accept doing this so far because we currently only use the Variant Selector on Document Workspace. [NL]
+            // This would need a refactor to enable the code below to work with different ContentTypes. Main problem here is the state, which is not generic for them all. [NL]
+            const workspaceContext = this.#splitViewContext.getWorkspaceContext();
+            if (!workspaceContext)
+                throw new Error('Split View Workspace context not found');
+            this.#observeVariants(workspaceContext);
+            this.#observeActiveVariants(workspaceContext);
+            this.#observeReadOnlyStates(workspaceContext);
             this.#observeCurrentVariant();
         });
         this.consumeContext(UMB_PROPERTY_DATASET_CONTEXT, (instance) => {
@@ -37,41 +51,25 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
             this.#observeCurrentVariant();
         });
     }
-    async #observeVariants() {
-        if (!this.#splitViewContext)
-            return;
-        // NOTICE: This is dirty (the TypeScript casting), we can only accept doing this so far because we currently only use the Variant Selector on Document Workspace. [NL]
-        // This would need a refactor to enable the code below to work with different ContentTypes. Main problem here is the state, which is not generic for them all. [NL]
-        const workspaceContext = this.#splitViewContext.getWorkspaceContext();
-        if (!workspaceContext)
-            throw new Error('Split View Workspace context not found');
-        this.observe(workspaceContext.variantOptions, (options) => {
-            this._variants = options.map((option) => {
-                const name = option.variant?.name ?? option.language.name;
-                const segment = option.segment;
-                return {
-                    // Notice the option object has a unique property, but it's not used here. (Its equivalent to a UmbVariantId string) [NL]
-                    culture: option.culture,
-                    segment: segment ?? null,
-                    title: name + (segment ? ` — ${segment}` : ''),
-                    displayName: name + (segment ? ` — ${segment}` : ''),
-                    state: option.variant?.state ?? DocumentVariantStateModel.NOT_CREATED,
-                };
-            });
-        }, '_observeVariants');
+    async #observeVariants(workspaceContext) {
+        this.observe(workspaceContext.variantOptions, (variantOptions) => {
+            this._variantOptions = variantOptions;
+            this.#setReadOnlyCultures();
+        }, '_observeVariantOptions');
     }
-    async #observeActiveVariants() {
-        if (!this.#splitViewContext)
-            return;
-        const workspaceContext = this.#splitViewContext.getWorkspaceContext();
-        if (workspaceContext) {
-            this.observe(workspaceContext.splitView.activeVariantsInfo, (activeVariants) => {
-                if (activeVariants) {
-                    this._activeVariants = activeVariants;
-                    this._activeVariantsCultures = this._activeVariants.map((el) => el.culture ?? '') ?? [];
-                }
-            }, '_observeActiveVariants');
-        }
+    async #observeReadOnlyStates(workspaceContext) {
+        this.observe(workspaceContext.readOnlyState.states, (states) => {
+            this._readOnlyStates = states;
+            this.#setReadOnlyCultures();
+        }, 'umbObserveReadOnlyStates');
+    }
+    async #observeActiveVariants(workspaceContext) {
+        this.observe(workspaceContext.splitView.activeVariantsInfo, (activeVariants) => {
+            if (activeVariants) {
+                this._activeVariants = activeVariants;
+                this._activeVariantsCultures = this._activeVariants.map((el) => el.culture ?? '') ?? [];
+            }
+        }, '_observeActiveVariants');
     }
     async #observeDatasetContext() {
         if (!this.#datasetContext)
@@ -86,16 +84,10 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
         const workspaceContext = this.#splitViewContext.getWorkspaceContext();
         if (!workspaceContext)
             return;
-        const variantId = this.#datasetContext.getVariantId();
-        // Find the variant option matching this, to get the language name...
-        const culture = variantId.culture;
-        const segment = variantId.segment;
+        this._variantId = this.#datasetContext.getVariantId();
         this.observe(workspaceContext.variantOptions, (options) => {
-            const option = options.find((option) => option.language.unique === culture);
-            const languageName = option?.language.name;
-            this._variantDisplayName = (languageName ? languageName : '') + (segment ? ` — ${segment}` : '');
-            this._variantTitleName =
-                (languageName ? `${languageName} ${culture ? `(${culture})` : ''}` : '') + (segment ? ` — ${segment}` : '');
+            const option = options.find((option) => option.language.unique === this._variantId?.culture);
+            this._activeVariant = option;
         }, '_currentLanguage');
     }
     #handleInput(event) {
@@ -120,11 +112,17 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
     #isVariantActive(culture) {
         return culture !== null ? this._activeVariantsCultures.includes(culture) : true;
     }
-    #isNotPublishedMode(culture, state) {
-        return state !== DocumentVariantStateModel.PUBLISHED && !this.#isVariantActive(culture);
+    #isCreateMode(variantOption) {
+        return !variantOption.variant && !this.#isVariantActive(variantOption.culture);
     }
     #hasVariants() {
-        return this._variants?.length > 1;
+        return this._variantOptions?.length > 1;
+    }
+    #setReadOnlyCultures() {
+        this._readOnlyCultures = this._variantOptions
+            .filter((variant) => this._readOnlyStates.some((state) => state.variantId.compare(variant)))
+            .map((variant) => variant.culture)
+            .filter((item) => item !== null);
     }
     #onPopoverToggle(event) {
         // TODO: This ignorer is just needed for JSON SCHEMA TO WORK, As its not updated with latest TS jet.
@@ -144,38 +142,42 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
         this._popoverElement.style.width = `${host.width}px`;
     }
     render() {
-        return html `
+        return this._variantId
+            ? html `
 			<uui-input
 				id="name-input"
 				label=${this.localize.term('placeholders_entername')}
 				.value=${this._name ?? ''}
 				@input=${this.#handleInput}
+				required
+				?readonly=${this.#isReadOnly(this._activeVariant?.culture ?? null)}
+				${umbBindToValidation(this, `$.variants[${UmbDataPathVariantQuery(this._variantId)}].name`, this._name ?? '')}
 				${umbFocus()}
 			>
 				${this.#hasVariants()
-            ? html `
+                ? html `
 								<uui-button
 									id="variant-selector-toggle"
 									compact
 									slot="append"
 									popovertarget="variant-selector-popover"
-									title=${this._variantTitleName}>
-									${this._variantDisplayName}
+									title=${ifDefined(this._activeVariant?.language.name)}>
+									${this._activeVariant?.language.name} ${this.#renderReadOnlyTag(this._activeVariant?.culture)}
 									<uui-symbol-expand .open=${this._variantSelectorOpen}></uui-symbol-expand>
 								</uui-button>
 								${this._activeVariants.length > 1
-                ? html `
+                    ? html `
 											<uui-button slot="append" compact id="variant-close" @click=${this.#closeSplitView}>
 												<uui-icon name="remove"></uui-icon>
 											</uui-button>
 										`
-                : ''}
+                    : ''}
 							`
-            : nothing}
+                : nothing}
 			</uui-input>
 
 			${this.#hasVariants()
-            ? html `
+                ? html `
 							<uui-popover-container
 								id="variant-selector-popover"
 								@beforetoggle=${this.#onPopoverToggle}
@@ -183,39 +185,64 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
 								<div id="variant-selector-dropdown">
 									<uui-scroll-container>
 										<ul>
-											${this._variants.map((variant) => html `
-													<li class="${this.#isVariantActive(variant.culture) ? 'selected' : ''}">
-														<button
-															class="variant-selector-switch-button
-																	${this.#isNotPublishedMode(variant.culture, variant.state) ? 'add-mode' : ''}"
-															@click=${() => this.#switchVariant(variant)}>
-															${this.#isNotPublishedMode(variant.culture, variant.state)
-                ? html `<uui-icon class="add-icon" name="icon-add"></uui-icon>`
-                : nothing}
-															<div>
-																${variant.title} ${variant.culture ? html ` <i>(${variant.culture})</i>` : ''}
-																${variant.segment}
-																<div class="variant-selector-state">${variant.state}</div>
-															</div>
-														</button>
-														${this.#isVariantActive(variant.culture)
-                ? nothing
-                : html `
-																	<uui-button
-																		class="variant-selector-split-view"
-																		@click=${() => this.#openSplitView(variant)}>
-																		Split view
-																	</uui-button>
-																`}
-													</li>
-												`)}
+											${this._variantOptions.map((variant) => this.#renderListItem(variant))}
 										</ul>
 									</uui-scroll-container>
 								</div>
 							</uui-popover-container>
 						`
-            : nothing}
+                : nothing}
 		</div>
+		`
+            : nothing;
+    }
+    #renderListItem(variantOption) {
+        return html `
+			<li class="${this.#isVariantActive(variantOption.culture) ? 'selected' : ''}">
+				<button
+					class="variant-selector-switch-button ${this.#isCreateMode(variantOption)
+            ? 'add-mode'
+            : ''} ${this.#isReadOnly(variantOption.culture) ? 'readonly-mode' : ''}"
+					@click=${() => this.#switchVariant(variantOption)}>
+					${this.#isCreateMode(variantOption) ? html `<uui-icon class="add-icon" name="icon-add"></uui-icon>` : nothing}
+					<div>
+						<div class="variant-name">
+							${variantOption.language.name} ${this.#renderReadOnlyTag(variantOption.culture)}
+						</div>
+						<div class="variant-publish-state">
+							${this.localize.term(this.#publishStateLocalizationMap[variantOption.variant?.state || DocumentVariantStateModel.NOT_CREATED])}
+							${variantOption.language.isDefault
+            ? html `<span> - ${this.localize.term('general_default')}</span>`
+            : nothing}
+						</div>
+					</div>
+				</button>
+				${this.#renderSplitViewButton(variantOption)}
+			</li>
+		`;
+    }
+    #isReadOnly(culture) {
+        if (!culture)
+            return false;
+        return this._readOnlyCultures.includes(culture);
+    }
+    #renderReadOnlyTag(culture) {
+        if (!culture)
+            return nothing;
+        return this.#isReadOnly(culture) ? html `<uui-tag look="secondary">Read-only</uui-tag>` : nothing;
+    }
+    #renderSplitViewButton(variant) {
+        return html `
+			${this.#isVariantActive(variant.culture)
+            ? nothing
+            : html `
+						<uui-button
+							label="Open Split view for ${variant.language.name}"
+							class="variant-selector-split-view"
+							@click=${() => this.#openSplitView(variant)}>
+							Split view
+						</uui-button>
+					`}
 		`;
     }
     static { this.styles = [
@@ -260,6 +287,10 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
 				margin-bottom: 1px;
 			}
 
+			li:hover .variant-selector-split-view {
+				display: flex;
+			}
+
 			li:nth-last-of-type(1) {
 				margin-bottom: 0;
 			}
@@ -319,6 +350,14 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
 				z-index: 1;
 			}
 
+			.variant-selector-switch-button .variant-name {
+				margin-bottom: var(--uui-size-space-1);
+			}
+
+			.variant-selector-switch-button.readonly-mode .variant-name {
+				margin-bottom: calc(var(--uui-size-space-1) * -1);
+			}
+
 			.add-icon {
 				font-size: 12px;
 				margin-right: 12px;
@@ -329,9 +368,10 @@ let UmbWorkspaceSplitViewVariantSelectorElement = class UmbWorkspaceSplitViewVar
 				top: 0;
 				right: 0;
 				bottom: 1px;
+				display: none;
 			}
 
-			.variant-selector-state {
+			.variant-publish-state {
 				color: var(--uui-palette-malibu-dimmed);
 				font-size: 12px;
 				font-weight: normal;
@@ -344,7 +384,10 @@ __decorate([
 ], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_popoverElement", void 0);
 __decorate([
     state()
-], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_variants", void 0);
+], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_variantOptions", void 0);
+__decorate([
+    state()
+], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_readOnlyStates", void 0);
 __decorate([
     state()
 ], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_activeVariants", void 0);
@@ -356,13 +399,16 @@ __decorate([
 ], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_name", void 0);
 __decorate([
     state()
-], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_variantDisplayName", void 0);
+], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_activeVariant", void 0);
 __decorate([
     state()
-], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_variantTitleName", void 0);
+], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_variantId", void 0);
 __decorate([
     state()
 ], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_variantSelectorOpen", void 0);
+__decorate([
+    state()
+], UmbWorkspaceSplitViewVariantSelectorElement.prototype, "_readOnlyCultures", void 0);
 UmbWorkspaceSplitViewVariantSelectorElement = __decorate([
     customElement(elementName)
 ], UmbWorkspaceSplitViewVariantSelectorElement);

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

@@ -1,3 +1,5 @@
 export type { WorkspaceAliasConditionConfig } from './workspace-alias.condition.js';
 export type { WorkspaceEntityTypeConditionConfig } from './workspace-entity-type.condition.js';
 export type { WorkspaceHasCollectionConditionConfig } from './workspace-has-collection.condition.js';
+export type { WorkspaceContentTypeAliasConditionConfig as WorkspaceEntityContentTypeConditionConfig } from './workspace-content-type-alias.condition.js';
+export type { WorkspaceContentTypeAliasConditionConfig } from './workspace-content-type-alias.condition.js';

package/dist-cms/packages/core/workspace/conditions/manifests.js

@@ -1,8 +1,10 @@
 import { manifest as workspaceAliasCondition } from './workspace-alias.condition.js';
 import { manifest as workspaceEntityTypeCondition } from './workspace-entity-type.condition.js';
 import { manifest as workspaceHasCollectionCondition } from './workspace-has-collection.condition.js';
+import { manifest as workspaceContentTypeAliasCondition } from './workspace-content-type-alias.condition.js';
 export const manifests = [
     workspaceAliasCondition,
     workspaceEntityTypeCondition,
     workspaceHasCollectionCondition,
+    workspaceContentTypeAliasCondition,
 ];

package/dist-cms/packages/core/workspace/conditions/workspace-content-type-alias.condition.d.ts

@@ -0,0 +1,24 @@
+import { UmbConditionBase } from '../../extension-registry/conditions/condition-base.controller.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import type { ManifestCondition, UmbConditionConfigBase, UmbConditionControllerArguments, UmbExtensionCondition } from '../../../../libs/extension-api/index.js';
+/**
+ * Condition to apply workspace extension based on a content type alias
+ */
+export declare class UmbWorkspaceContentTypeAliasCondition extends UmbConditionBase<WorkspaceContentTypeAliasConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<WorkspaceContentTypeAliasConditionConfig>);
+}
+export type WorkspaceContentTypeAliasConditionConfig = UmbConditionConfigBase<'Umb.Condition.WorkspaceContentTypeAlias'> & {
+    /**
+     * Define a content type alias in which workspace this extension should be available
+     * @example
+     * Depends on implementation, but i.e. "article", "image", "blockPage"
+     */
+    match?: string;
+    /**
+     * Define one or more content type aliases in which workspace this extension should be available
+     * @example
+     * ["article", "image", "blockPage"]
+     */
+    oneOf?: Array<string>;
+};
+export declare const manifest: ManifestCondition;

package/dist-cms/packages/core/workspace/conditions/workspace-content-type-alias.condition.js

@@ -0,0 +1,34 @@
+import { UmbConditionBase } from '../../extension-registry/conditions/condition-base.controller.js';
+import { UMB_PROPERTY_STRUCTURE_WORKSPACE_CONTEXT } from '../index.js';
+const ObserveSymbol = Symbol();
+/**
+ * Condition to apply workspace extension based on a content type alias
+ */
+export class UmbWorkspaceContentTypeAliasCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        let permissionCheck = undefined;
+        if (this.config.match) {
+            permissionCheck = (contentTypeAliases) => contentTypeAliases.includes(this.config.match);
+        }
+        else if (this.config.oneOf) {
+            permissionCheck = (contentTypeAliases) => contentTypeAliases.some((item) => this.config.oneOf.includes(item));
+        }
+        if (permissionCheck !== undefined) {
+            this.consumeContext(UMB_PROPERTY_STRUCTURE_WORKSPACE_CONTEXT, (context) => {
+                this.observe(context.structure.contentTypeAliases, (contentTypeAliases) => {
+                    this.permitted = contentTypeAliases ? permissionCheck(contentTypeAliases) : false;
+                }, ObserveSymbol);
+            });
+        }
+        else {
+            throw new Error('Condition `Umb.Condition.WorkspaceContentTypeAlias` could not be initialized properly. Either "match" or "oneOf" must be defined');
+        }
+    }
+}
+export const manifest = {
+    type: 'condition',
+    name: 'Workspace Content Type Alias Condition',
+    alias: 'Umb.Condition.WorkspaceContentTypeAlias',
+    api: UmbWorkspaceContentTypeAliasCondition,
+};

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

@@ -4,14 +4,18 @@ import type { UmbControllerHost } from '../../../../libs/controller-api/index.js
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import type { UmbModalContext } from '../../modal/index.js';
 import type { Observable } from '../../../../external/rxjs/index.js';
-import { UmbValidationContext } from '../../validation/index.js';
+import type { UmbValidationController } from '../../validation/index.js';
 export declare abstract class UmbSubmittableWorkspaceContextBase<WorkspaceDataModelType> extends UmbContextBase<UmbSubmittableWorkspaceContextBase<WorkspaceDataModelType>> implements UmbSubmittableWorkspaceContext {
     #private;
     readonly workspaceAlias: string;
     readonly modalContext?: UmbModalContext<{
         preset: object;
     }>;
-    readonly validation: UmbValidationContext;
+    /**
+     * Appends a validation context to the workspace.
+     * @param context
+     */
+    addValidationContext(context: UmbValidationController): void;
     abstract readonly unique: Observable<string | null | undefined>;
     isNew: Observable<boolean | undefined>;
     readonly routes: UmbWorkspaceRouteManager;
@@ -19,6 +23,11 @@ export declare abstract class UmbSubmittableWorkspaceContextBase<WorkspaceDataMo
     protected resetState(): void;
     getIsNew(): boolean | undefined;
     protected setIsNew(isNew: boolean): void;
+    /**
+     * If a Workspace has multiple validation contexts, then this method can be overwritten to return the correct one.
+     * @returns Promise that resolves to void when the validation is complete.
+     */
+    validate(): Promise<Array<void>>;
     requestSubmit(): Promise<void>;
     protected validateAndSubmit(onValid: () => Promise<void>, onInvalid: () => Promise<void>): Promise<void>;
     abstract getUnique(): string | undefined;

package/dist-cms/packages/core/workspace/contexts/submittable-workspace-context-base.js

@@ -3,8 +3,16 @@ import { UMB_WORKSPACE_CONTEXT } from './tokens/workspace.context-token.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbBooleanState } from '../../../../libs/observable-api/index.js';
 import { UMB_MODAL_CONTEXT } from '../../modal/index.js';
-import { UmbValidationContext } from '../../validation/index.js';
 export class UmbSubmittableWorkspaceContextBase extends UmbContextBase {
+    //public readonly validation = new UmbValidationContext(this);
+    #validationContexts;
+    /**
+     * Appends a validation context to the workspace.
+     * @param context
+     */
+    addValidationContext(context) {
+        this.#validationContexts.push(context);
+    }
     #submitPromise;
     #submitResolve;
     #submitReject;
@@ -18,12 +26,14 @@ export class UmbSubmittableWorkspaceContextBase extends UmbContextBase {
     //isDirty = this.#isNew.asObservable();
     constructor(host, workspaceAlias) {
         super(host, UMB_WORKSPACE_CONTEXT.toString());
-        this.validation = new UmbValidationContext(this);
+        //public readonly validation = new UmbValidationContext(this);
+        this.#validationContexts = [];
         this.#isNew = new UmbBooleanState(undefined);
         this.isNew = this.#isNew.asObservable();
         this.routes = new UmbWorkspaceRouteManager(this);
         this.#rejectSubmit = () => {
             if (this.#submitPromise) {
+                // TODO: Capture the validation contexts messages on open, and then reset to them in this case. [NL]
                 this.#submitReject?.();
                 this.#submitPromise = undefined;
                 this.#submitResolve = undefined;
@@ -45,16 +55,18 @@ export class UmbSubmittableWorkspaceContextBase extends UmbContextBase {
         this.#completeSubmit = () => {
             this.#resolveSubmit();
             // Calling reset on the validation context here. [NL]
-            this.validation.reset();
+            // TODO: Capture the validation messages on open, and then reset to that.
+            //this.validation.reset();
         };
         this.workspaceAlias = workspaceAlias;
-        // TODO: Consider if we can turn this consumption to submitComplete, just as a getContext. [NL]
+        // TODO: Consider if we can move this consumption to #resolveSubmit, just as a getContext, but it depends if others use the modalContext prop.. [NL]
         this.consumeContext(UMB_MODAL_CONTEXT, (context) => {
             this.modalContext = context;
         });
     }
     resetState() {
-        this.validation.reset();
+        //this.validation.reset();
+        this.#validationContexts.forEach((context) => context.reset());
         this.#isNew.setValue(undefined);
     }
     getIsNew() {
@@ -63,6 +75,14 @@ export class UmbSubmittableWorkspaceContextBase extends UmbContextBase {
     setIsNew(isNew) {
         this.#isNew.setValue(isNew);
     }
+    /**
+     * If a Workspace has multiple validation contexts, then this method can be overwritten to return the correct one.
+     * @returns Promise that resolves to void when the validation is complete.
+     */
+    async validate() {
+        //return this.validation.validate();
+        return Promise.all(this.#validationContexts.map((context) => context.validate()));
+    }
     async requestSubmit() {
         return this.validateAndSubmit(() => this.submit(), () => this.invalidSubmit());
     }
@@ -74,7 +94,7 @@ export class UmbSubmittableWorkspaceContextBase extends UmbContextBase {
             this.#submitResolve = resolve;
             this.#submitReject = reject;
         });
-        this.validation.validate().then(async () => {
+        this.validate().then(async () => {
             onValid().then(this.#completeSubmit, this.#rejectSubmit);
         }, async () => {
             onInvalid().then(this.#resolveSubmit, this.#rejectSubmit);

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

@@ -6,9 +6,3 @@ export interface UmbCollectionWorkspaceContext<T extends UmbContentTypeModel> ex
     getCollectionAlias(): string;
     structure: UmbContentTypeStructureManager<T>;
 }
-/**
- * @deprecated Use UmbCollectionWorkspaceContextInterface instead — Will be removed before RC.
- * TODO: Delete before RC.
- */
-export interface UmbWorkspaceCollectionContextInterface<T extends UmbContentTypeModel> extends UmbCollectionWorkspaceContext<T> {
-}

package/dist-cms/packages/core/workspace/contexts/tokens/invariant-dataset-workspace-context.interface.d.ts

@@ -12,9 +12,3 @@ export interface UmbInvariantDatasetWorkspaceContext extends UmbSubmittableWorks
     setPropertyValue(alias: string, value: unknown): Promise<void>;
     createPropertyDatasetContext(host: UmbControllerHost, variantId?: UmbVariantId): UmbPropertyDatasetContext;
 }
-/**
- * @deprecated Use UmbInvariantWorkspaceContextInterface instead — Will be removed before RC.
- * TODO: Delete before RC.
- */
-export interface UmbInvariantableWorkspaceContextInterface extends UmbInvariantDatasetWorkspaceContext {
-}