@umbraco-cms/backoffice 14.0.0-rc2 → 14.0.0-rc4

package/dist-cms/packages/documents/documents/workspace/document-workspace.context.js

@@ -1,15 +1,3 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _UmbDocumentWorkspaceContext_instances, _UmbDocumentWorkspaceContext_parent, _UmbDocumentWorkspaceContext_persistedData, _UmbDocumentWorkspaceContext_currentData, _UmbDocumentWorkspaceContext_getDataPromise, _UmbDocumentWorkspaceContext_languageRepository, _UmbDocumentWorkspaceContext_languages, _UmbDocumentWorkspaceContext_serverValidation, _UmbDocumentWorkspaceContext_serverValidationValuesTranslator, _UmbDocumentWorkspaceContext_validationRepository, _UmbDocumentWorkspaceContext_blueprintRepository, _UmbDocumentWorkspaceContext_varies, _UmbDocumentWorkspaceContext_entityContext, _UmbDocumentWorkspaceContext_onStoreChange, _UmbDocumentWorkspaceContext_calculateChangedVariants, _UmbDocumentWorkspaceContext_updateVariantData, _UmbDocumentWorkspaceContext_determineVariantOptions, _UmbDocumentWorkspaceContext_buildSaveData, _UmbDocumentWorkspaceContext_performSaveOrCreate, _UmbDocumentWorkspaceContext_handleSaveAndPublish, _UmbDocumentWorkspaceContext_performSaveAndPublish, _UmbDocumentWorkspaceContext_handleSave;
 import { UmbDocumentTypeDetailRepository } from '../../document-types/repository/detail/document-type-detail.repository.js';
 import { UmbDocumentPropertyDataContext } from '../property-dataset-context/document-property-dataset-context.js';
 import { UMB_DOCUMENT_ENTITY_TYPE } from '../entity.js';
@@ -18,6 +6,9 @@ import { UMB_DOCUMENT_PUBLISH_MODAL, UMB_DOCUMENT_PUBLISH_WITH_DESCENDANTS_MODAL
 import { UmbDocumentPublishingRepository } from '../repository/publishing/index.js';
 import { UmbUnpublishDocumentEntityAction } from '../entity-actions/unpublish.action.js';
 import { UmbDocumentValidationRepository } from '../repository/validation/document-validation.repository.js';
+import { UMB_CREATE_DOCUMENT_WORKSPACE_PATH_PATTERN, UMB_CREATE_FROM_BLUEPRINT_DOCUMENT_WORKSPACE_PATH_PATTERN, UMB_EDIT_DOCUMENT_WORKSPACE_PATH_PATTERN, } from '../paths.js';
+import { UMB_DOCUMENTS_SECTION_PATH } from '../../paths.js';
+import { UmbDocumentPreviewRepository } from '../repository/preview/index.js';
 import { UMB_DOCUMENT_WORKSPACE_ALIAS } from './manifests.js';
 import { UmbEntityContext } from '../../../core/entity/index.js';
 import { UMB_INVARIANT_CULTURE, UmbVariantId } from '../../../core/variant/index.js';
@@ -27,53 +18,69 @@ import { appendToFrozenArray, mergeObservables, jsonStringComparison, UmbArraySt
 import { UmbLanguageCollectionRepository } from '../../../language/index.js';
 import { firstValueFrom } from '../../../../external/rxjs/index.js';
 import { UMB_ACTION_EVENT_CONTEXT } from '../../../core/action/index.js';
-import { UmbRequestReloadTreeItemChildrenEvent } from '../../../core/tree/index.js';
-import { UmbRequestReloadStructureForEntityEvent } from '../../../core/entity-action/index.js';
+import { UmbRequestReloadChildrenOfEntityEvent, UmbRequestReloadStructureForEntityEvent, } from '../../../core/entity-action/index.js';
 import { UMB_MODAL_MANAGER_CONTEXT } from '../../../core/modal/index.js';
 import { UmbServerModelValidationContext, UmbVariantValuesValidationMessageTranslator, } from '../../../core/validation/index.js';
 import { UmbDocumentBlueprintDetailRepository } from '../../document-blueprints/index.js';
 import { UMB_NOTIFICATION_CONTEXT } from '../../../core/notification/index.js';
+import { UmbIsTrashedEntityContext } from '../../../core/recycle-bin/index.js';
 export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextBase {
+    #parent;
+    /**
+     * The document is the current state/draft version of the document.
+     */
+    #persistedData;
+    #currentData;
+    #getDataPromise;
+    // TODo: Optimize this so it uses either a App Language Context? [NL]
+    #languageRepository;
+    #languages;
+    #serverValidation;
+    #serverValidationValuesTranslator;
+    #validationRepository;
+    #blueprintRepository;
     /*#blueprint = new UmbObjectState<UmbDocumentBlueprintDetailModel | undefined>(undefined);
     public readonly blueprint = this.#blueprint.asObservable();*/
     isLoaded() {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_getDataPromise, "f");
+        return this.#getDataPromise;
     }
+    #varies;
+    // TODO: this should be set up for all entity workspace contexts in a base class
+    #entityContext;
+    // TODO: this might not be the correct place to spin this up
+    #isTrashedContext;
     constructor(host) {
         super(host, UMB_DOCUMENT_WORKSPACE_ALIAS);
-        _UmbDocumentWorkspaceContext_instances.add(this);
         this.IS_CONTENT_WORKSPACE_CONTEXT = true;
         this.repository = new UmbDocumentDetailRepository(this);
         this.publishingRepository = new UmbDocumentPublishingRepository(this);
-        _UmbDocumentWorkspaceContext_parent.set(this, new UmbObjectState(undefined));
-        this.parentUnique = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_parent, "f").asObservablePart((parent) => (parent ? parent.unique : undefined));
+        this.#parent = new UmbObjectState(undefined);
+        this.parentUnique = this.#parent.asObservablePart((parent) => (parent ? parent.unique : undefined));
+        this.parentEntityType = this.#parent.asObservablePart((parent) => (parent ? parent.entityType : undefined));
         /**
          * The document is the current state/draft version of the document.
          */
-        _UmbDocumentWorkspaceContext_persistedData.set(this, new UmbObjectState(undefined));
-        _UmbDocumentWorkspaceContext_currentData.set(this, new UmbObjectState(undefined));
-        _UmbDocumentWorkspaceContext_getDataPromise.set(this, void 0);
+        this.#persistedData = new UmbObjectState(undefined);
+        this.#currentData = new UmbObjectState(undefined);
         // TODo: Optimize this so it uses either a App Language Context? [NL]
-        _UmbDocumentWorkspaceContext_languageRepository.set(this, new UmbLanguageCollectionRepository(this));
-        _UmbDocumentWorkspaceContext_languages.set(this, new UmbArrayState([], (x) => x.unique));
-        this.languages = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_languages, "f").asObservable();
-        _UmbDocumentWorkspaceContext_serverValidation.set(this, new UmbServerModelValidationContext(this));
-        _UmbDocumentWorkspaceContext_serverValidationValuesTranslator.set(this, new UmbVariantValuesValidationMessageTranslator(this, __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_serverValidation, "f")));
-        _UmbDocumentWorkspaceContext_validationRepository.set(this, void 0);
-        _UmbDocumentWorkspaceContext_blueprintRepository.set(this, new UmbDocumentBlueprintDetailRepository(this));
-        this.unique = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.unique);
-        this.contentTypeUnique = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.documentType.unique);
-        this.contentTypeHasCollection = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => !!data?.documentType.collection);
-        this.variants = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.variants ?? []);
-        this.urls = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.urls || []);
-        this.templateId = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.template?.unique || null);
+        this.#languageRepository = new UmbLanguageCollectionRepository(this);
+        this.#languages = new UmbArrayState([], (x) => x.unique);
+        this.languages = this.#languages.asObservable();
+        this.#serverValidation = new UmbServerModelValidationContext(this);
+        this.#serverValidationValuesTranslator = new UmbVariantValuesValidationMessageTranslator(this, this.#serverValidation);
+        this.#blueprintRepository = new UmbDocumentBlueprintDetailRepository(this);
+        this.unique = this.#currentData.asObservablePart((data) => data?.unique);
+        this.entityType = this.#currentData.asObservablePart((data) => data?.entityType);
+        this.isTrashed = this.#currentData.asObservablePart((data) => data?.isTrashed);
+        this.contentTypeUnique = this.#currentData.asObservablePart((data) => data?.documentType.unique);
+        this.contentTypeHasCollection = this.#currentData.asObservablePart((data) => !!data?.documentType.collection);
+        this.variants = this.#currentData.asObservablePart((data) => data?.variants ?? []);
+        this.urls = this.#currentData.asObservablePart((data) => data?.urls || []);
+        this.templateId = this.#currentData.asObservablePart((data) => data?.template?.unique || null);
         this.structure = new UmbContentTypeStructureManager(this, new UmbDocumentTypeDetailRepository(this));
         this.variesByCulture = this.structure.ownerContentTypePart((x) => x?.variesByCulture);
-        //#variesByCulture?: boolean;
         this.variesBySegment = this.structure.ownerContentTypePart((x) => x?.variesBySegment);
-        //#variesBySegment?: boolean;
         this.varies = this.structure.ownerContentTypePart((x) => x ? x.variesByCulture || x.variesBySegment : undefined);
-        _UmbDocumentWorkspaceContext_varies.set(this, void 0);
         this.routes = new UmbWorkspaceRouteManager(this);
         this.splitView = new UmbWorkspaceSplitViewManager();
         this.variantOptions = mergeObservables([this.varies, this.variants, this.languages], ([varies, variants, languages]) => {
@@ -105,16 +112,23 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
             return [];
         });
         // TODO: this should be set up for all entity workspace contexts in a base class
-        _UmbDocumentWorkspaceContext_entityContext.set(this, new UmbEntityContext(this));
+        this.#entityContext = new UmbEntityContext(this);
+        // TODO: this might not be the correct place to spin this up
+        this.#isTrashedContext = new UmbIsTrashedEntityContext(this);
+        this.#updateLock = 0;
+        this.finishPropertyValueChange = () => {
+            this.#updateLock--;
+            this.#triggerPropertyValueChanges();
+        };
         this.observe(this.contentTypeUnique, (unique) => this.structure.loadType(unique));
-        this.observe(this.varies, (varies) => (__classPrivateFieldSet(this, _UmbDocumentWorkspaceContext_varies, varies, "f")));
+        this.observe(this.varies, (varies) => (this.#varies = varies));
         this.loadLanguages();
         this.routes.setRoutes([
             {
-                path: 'create/parent/:entityType/:parentUnique/:documentTypeUnique/blueprint/:blueprintUnique',
+                path: UMB_CREATE_FROM_BLUEPRINT_DOCUMENT_WORKSPACE_PATH_PATTERN.toString(),
                 component: () => import('./document-workspace-editor.element.js'),
                 setup: async (_component, info) => {
-                    const parentEntityType = info.match.params.entityType;
+                    const parentEntityType = info.match.params.parentEntityType;
                     const parentUnique = info.match.params.parentUnique === 'null' ? null : info.match.params.parentUnique;
                     const documentTypeUnique = info.match.params.documentTypeUnique;
                     const blueprintUnique = info.match.params.blueprintUnique;
@@ -123,10 +137,10 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
                 },
             },
             {
-                path: 'create/parent/:entityType/:parentUnique/:documentTypeUnique',
+                path: UMB_CREATE_DOCUMENT_WORKSPACE_PATH_PATTERN.toString(),
                 component: () => import('./document-workspace-editor.element.js'),
                 setup: async (_component, info) => {
-                    const parentEntityType = info.match.params.entityType;
+                    const parentEntityType = info.match.params.parentEntityType;
                     const parentUnique = info.match.params.parentUnique === 'null' ? null : info.match.params.parentUnique;
                     const documentTypeUnique = info.match.params.documentTypeUnique;
                     this.create({ entityType: parentEntityType, unique: parentUnique }, documentTypeUnique);
@@ -134,7 +148,7 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
                 },
             },
             {
-                path: 'edit/:unique',
+                path: UMB_EDIT_DOCUMENT_WORKSPACE_PATH_PATTERN.toString(),
                 component: () => import('./document-workspace-editor.element.js'),
                 setup: (_component, info) => {
                     const unique = info.match.params.unique;
@@ -145,61 +159,68 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
     }
     resetState() {
         super.resetState();
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").setValue(undefined);
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").setValue(undefined);
+        this.#persistedData.setValue(undefined);
+        this.#currentData.setValue(undefined);
     }
     async loadLanguages() {
         // TODO: If we don't end up having a Global Context for languages, then we should at least change this into using a asObservable which should be returned from the repository. [Nl]
-        const { data } = await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_languageRepository, "f").requestCollection({});
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_languages, "f").setValue(data?.items ?? []);
+        const { data } = await this.#languageRepository.requestCollection({});
+        this.#languages.setValue(data?.items ?? []);
     }
     async load(unique) {
         this.resetState();
-        __classPrivateFieldSet(this, _UmbDocumentWorkspaceContext_getDataPromise, this.repository.requestByUnique(unique), "f");
-        const { data, asObservable } = (await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_getDataPromise, "f"));
+        this.#getDataPromise = this.repository.requestByUnique(unique);
+        const { data, asObservable } = (await this.#getDataPromise);
         if (data) {
-            __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_entityContext, "f").setEntityType(UMB_DOCUMENT_ENTITY_TYPE);
-            __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_entityContext, "f").setUnique(unique);
+            this.#entityContext.setEntityType(UMB_DOCUMENT_ENTITY_TYPE);
+            this.#entityContext.setUnique(unique);
+            this.#isTrashedContext.setIsTrashed(data.isTrashed);
             this.setIsNew(false);
-            __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").setValue(data);
-            __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").setValue(data);
+            this.#persistedData.setValue(data);
+            this.#currentData.setValue(data);
+        }
+        this.observe(asObservable(), (entity) => this.#onStoreChange(entity), 'umbDocumentStoreObserver');
+    }
+    #onStoreChange(entity) {
+        if (!entity) {
+            //TODO: This solution is alright for now. But reconsider when we introduce signal-r
+            history.pushState(null, '', UMB_DOCUMENTS_SECTION_PATH);
         }
-        this.observe(asObservable(), (entity) => __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_onStoreChange).call(this, entity), 'umbDocumentStoreObserver');
     }
     async create(parent, documentTypeUnique, blueprintUnique) {
         this.resetState();
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_parent, "f").setValue(parent);
+        this.#parent.setValue(parent);
         if (blueprintUnique) {
-            const { data } = await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_blueprintRepository, "f").requestByUnique(blueprintUnique);
-            __classPrivateFieldSet(this, _UmbDocumentWorkspaceContext_getDataPromise, this.repository.createScaffold({
+            const { data } = await this.#blueprintRepository.requestByUnique(blueprintUnique);
+            this.#getDataPromise = this.repository.createScaffold({
                 documentType: data?.documentType,
                 values: data?.values,
                 variants: data?.variants,
-            }), "f");
+            });
         }
         else {
-            __classPrivateFieldSet(this, _UmbDocumentWorkspaceContext_getDataPromise, this.repository.createScaffold({
+            this.#getDataPromise = this.repository.createScaffold({
                 documentType: {
                     unique: documentTypeUnique,
                     collection: null,
                 },
-            }), "f");
+            });
         }
-        const { data } = await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_getDataPromise, "f");
+        const { data } = await this.#getDataPromise;
         if (!data)
             return undefined;
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_entityContext, "f").setEntityType(UMB_DOCUMENT_ENTITY_TYPE);
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_entityContext, "f").setUnique(data.unique);
+        this.#entityContext.setEntityType(UMB_DOCUMENT_ENTITY_TYPE);
+        this.#entityContext.setUnique(data.unique);
         this.setIsNew(true);
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").setValue(undefined);
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").setValue(data);
+        this.#persistedData.setValue(undefined);
+        this.#currentData.setValue(data);
         return data;
     }
     getCollectionAlias() {
         return 'Umb.Collection.Document';
     }
     getData() {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").getValue();
+        return this.#currentData.getValue();
     }
     getUnique() {
         return this.getData()?.unique;
@@ -212,7 +233,7 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
     }
     // TODO: Check if this is used:
     getVaries() {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_varies, "f");
+        return this.#varies;
     }
     /*
     getVariesByCulture() {
@@ -222,13 +243,13 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
         return this.#variesBySegment;
     }*/
     variantById(variantId) {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.variants?.find((x) => variantId.compare(x)));
+        return this.#currentData.asObservablePart((data) => data?.variants?.find((x) => variantId.compare(x)));
     }
     getVariant(variantId) {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").getValue()?.variants?.find((x) => variantId.compare(x));
+        return this.#currentData.getValue()?.variants?.find((x) => variantId.compare(x));
     }
     getName(variantId) {
-        const variants = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").getValue()?.variants;
+        const variants = this.#currentData.getValue()?.variants;
         if (!variants)
             return;
         if (variantId) {
@@ -239,34 +260,25 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
         }
     }
     setName(name, variantId) {
-        /*
-        const oldVariants = this.#currentData.getValue()?.variants || [];
-        const variants = partialUpdateFrozenArray(
-            oldVariants,
-            { name },
-            variantId ? (x) => variantId.compare(x) : () => true,
-        );
-        this.#currentData.update({ variants });
-        */
         // TODO: We should move this type of logic to the act of saving [NL]
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_updateVariantData).call(this, variantId ?? UmbVariantId.CreateInvariant(), { name });
+        this.#updateVariantData(variantId ?? UmbVariantId.CreateInvariant(), { name });
     }
     name(variantId) {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.variants?.find((x) => variantId?.compare(x))?.name ?? '');
+        return this.#currentData.asObservablePart((data) => data?.variants?.find((x) => variantId?.compare(x))?.name ?? '');
     }
     setTemplate(templateUnique) {
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").update({ template: { unique: templateUnique } });
+        this.#currentData.update({ template: { unique: templateUnique } });
     }
     async propertyStructureById(propertyId) {
         return this.structure.propertyStructureById(propertyId);
     }
     async propertyValueByAlias(propertyAlias, variantId) {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.values?.find((x) => x?.alias === propertyAlias && (variantId ? variantId.compare(x) : true))
+        return this.#currentData.asObservablePart((data) => data?.values?.find((x) => x?.alias === propertyAlias && (variantId ? variantId.compare(x) : true))
             ?.value);
     }
     // TODO: Re-evaluate if this is begin used, i wrote this as part of a POC... [NL]
     async propertyIndexByAlias(propertyAlias, variantId) {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").asObservablePart((data) => data?.values?.findIndex((x) => x?.alias === propertyAlias && (variantId ? variantId.compare(x) : true)));
+        return this.#currentData.asObservablePart((data) => data?.values?.findIndex((x) => x?.alias === propertyAlias && (variantId ? variantId.compare(x) : true)));
     }
     /**
      * Get the current value of the property with the given alias and variantId.
@@ -283,33 +295,333 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
         return undefined;
     }
     async setPropertyValue(alias, value, variantId) {
-        variantId ?? (variantId = UmbVariantId.CreateInvariant());
+        variantId ??= UmbVariantId.CreateInvariant();
         const entry = { ...variantId.toObject(), alias, value };
         const currentData = this.getData();
         if (currentData) {
             const values = appendToFrozenArray(currentData.values ?? [], entry, (x) => x.alias === alias && variantId.compare(x));
-            __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").update({ values });
+            this.#currentData.update({ values });
             // TODO: We should move this type of logic to the act of saving [NL]
-            __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_updateVariantData).call(this, variantId);
+            this.#updateVariantData(variantId);
+        }
+    }
+    #updateLock;
+    initiatePropertyValueChange() {
+        this.#updateLock++;
+        this.#currentData.mute();
+        // TODO: When ready enable this code will enable handling a finish automatically by this implementation 'using myState.initiatePropertyValueChange()' (Relies on TS support of Using) [NL]
+        /*return {
+            [Symbol.dispose]: this.finishPropertyValueChange,
+        };*/
+    }
+    #triggerPropertyValueChanges() {
+        if (this.#updateLock === 0) {
+            this.#currentData.unmute();
+        }
+    }
+    #calculateChangedVariants() {
+        const persisted = this.#persistedData.getValue();
+        const current = this.#currentData.getValue();
+        if (!current)
+            throw new Error('Current data is missing');
+        const changedVariants = current?.variants.map((variant) => {
+            const persistedVariant = persisted?.variants.find((x) => UmbVariantId.Create(variant).compare(x));
+            return {
+                culture: variant.culture,
+                segment: variant.segment,
+                equal: persistedVariant ? jsonStringComparison(variant, persistedVariant) : false,
+            };
+        });
+        const changedProperties = current?.values.map((value) => {
+            const persistedValues = persisted?.values.find((x) => UmbVariantId.Create(value).compare(x));
+            return {
+                culture: value.culture,
+                segment: value.segment,
+                equal: persistedValues ? jsonStringComparison(value, persistedValues) : false,
+            };
+        });
+        // calculate the variantIds of those who either have a change in properties or in variants:
+        return (changedVariants
+            ?.concat(changedProperties ?? [])
+            .filter((x) => x.equal === false)
+            .map((x) => new UmbVariantId(x.culture, x.segment)) ?? []);
+    }
+    #updateVariantData(variantId, update) {
+        const currentData = this.getData();
+        if (!currentData)
+            throw new Error('Data is missing');
+        if (this.#varies === true) {
+            // If variant Id is invariant, we don't to have the variant appended to our data.
+            if (variantId.isInvariant())
+                return;
+            const variant = currentData.variants.find((x) => variantId.compare(x));
+            const newVariants = appendToFrozenArray(currentData.variants, {
+                state: null,
+                name: '',
+                publishDate: null,
+                createDate: null,
+                updateDate: null,
+                ...variantId.toObject(),
+                ...variant,
+                ...update,
+            }, (x) => variantId.compare(x));
+            this.#currentData.update({ variants: newVariants });
+        }
+        else if (this.#varies === false) {
+            // TODO: Beware about segments, in this case we need to also consider segments, if its allowed to vary by segments.
+            const invariantVariantId = UmbVariantId.CreateInvariant();
+            const variant = currentData.variants.find((x) => invariantVariantId.compare(x));
+            // Cause we are invariant, we will just overwrite all variants with this one:
+            const newVariants = [
+                {
+                    state: null,
+                    name: '',
+                    publishDate: null,
+                    createDate: null,
+                    updateDate: null,
+                    ...invariantVariantId.toObject(),
+                    ...variant,
+                    ...update,
+                },
+            ];
+            this.#currentData.update({ variants: newVariants });
+        }
+        else {
+            throw new Error('Varies by culture is missing');
+        }
+    }
+    async #determineVariantOptions() {
+        const activeVariants = this.splitView.getActiveVariants();
+        const activeVariantIds = activeVariants.map((activeVariant) => UmbVariantId.Create(activeVariant));
+        // TODO: We need to filter the selected array, so it only contains one of each variantId. [NL]
+        const changedVariantIds = this.#calculateChangedVariants();
+        const selected = activeVariantIds.concat(changedVariantIds);
+        // Selected can contain entries that are not part of the options, therefor the modal filters selection based on options.
+        const options = await firstValueFrom(this.variantOptions);
+        return {
+            options,
+            selected: selected.map((x) => x.toString()).filter((v, i, a) => a.indexOf(v) === i),
+        };
+    }
+    #buildSaveData(selectedVariants) {
+        const data = this.getData();
+        if (!data)
+            throw new Error('Data is missing');
+        if (!data.unique)
+            throw new Error('Unique is missing');
+        const invariantVariantId = UmbVariantId.CreateInvariant();
+        if (this.#varies === false) {
+            // If we do not vary, we wil just do this for the invariant variant id.
+            selectedVariants = [invariantVariantId];
+        }
+        const persistedData = this.#persistedData.getValue();
+        const variantIdsToParseForValues = [...selectedVariants];
+        if (this.#varies === true) {
+            // If we vary then We need to include the invariant variant id for invariant values to be saved, as we always want to save the invariant values.
+            variantIdsToParseForValues.push(invariantVariantId);
+        }
+        // Combine data and persisted data depending on the selectedVariants. Always use the invariant values from the data.
+        // loops over each entry in values, determine wether the value should be from the data or the persisted data, depending on wether its a selectedVariant or an invariant value.
+        // loops over each entry in variants, determine wether the variant should be from the data or the persisted data, depending on the selectedVariants.
+        return {
+            ...data,
+            values: data.values
+                .map((value) => {
+                // Should this value be saved?
+                if (variantIdsToParseForValues.some((x) => x.compare(value))) {
+                    return value;
+                }
+                else {
+                    // If not, then we will find the value in the persisted data and use that instead.
+                    return persistedData?.values.find((x) => x.alias === value.alias && x.culture === value.culture && x.segment === value.segment);
+                }
+            })
+                .filter((x) => x !== undefined),
+            variants: data.variants
+                .map((variant) => {
+                // Should this value be saved?
+                if (selectedVariants.some((x) => x.compare(variant))) {
+                    return variant;
+                }
+                else {
+                    // If not we will find the value in the persisted data and use that instead.
+                    return persistedData?.variants.find((x) => x.culture === variant.culture && x.segment === variant.segment);
+                }
+            })
+                .filter((x) => x !== undefined),
+        };
+    }
+    async #performSaveOrCreate(saveData) {
+        if (this.getIsNew()) {
+            const parent = this.#parent.getValue();
+            if (!parent)
+                throw new Error('Parent is not set');
+            const { data, error } = await this.repository.create(saveData, parent.unique);
+            if (!data || error) {
+                console.error('Error creating document', error);
+                throw new Error('Error creating document');
+            }
+            this.setIsNew(false);
+            this.#persistedData.setValue(data);
+            this.#currentData.setValue(data);
+            // TODO: this might not be the right place to alert the tree, but it works for now
+            const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
+            const event = new UmbRequestReloadChildrenOfEntityEvent({
+                entityType: parent.entityType,
+                unique: parent.unique,
+            });
+            eventContext.dispatchEvent(event);
+        }
+        else {
+            const { data, error } = await this.repository.save(saveData);
+            if (!data || error) {
+                console.error('Error saving document', error);
+                throw new Error('Error saving document');
+            }
+            this.#persistedData.setValue(data);
+            this.#currentData.setValue(data);
+            const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
+            const event = new UmbRequestReloadStructureForEntityEvent({
+                unique: this.getUnique(),
+                entityType: this.getEntityType(),
+            });
+            eventContext.dispatchEvent(event);
+        }
+    }
+    async #handleSaveAndPreview() {
+        const unique = this.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        let culture = UMB_INVARIANT_CULTURE;
+        // Save document (the active variant) before previewing.
+        const { selected } = await this.#determineVariantOptions();
+        if (selected.length > 0) {
+            culture = selected[0];
+            const variantId = UmbVariantId.FromString(culture);
+            const saveData = this.#buildSaveData([variantId]);
+            await this.#performSaveOrCreate(saveData);
+        }
+        // Tell the server that we're entering preview mode.
+        await new UmbDocumentPreviewRepository(this).enter();
+        const preview = window.open(`preview?id=${unique}&culture=${culture}`, 'umbpreview');
+        preview?.focus();
+    }
+    async #handleSaveAndPublish() {
+        const unique = this.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        let variantIds = [];
+        const { options, selected } = await this.#determineVariantOptions();
+        // If there is only one variant, we don't need to open the modal.
+        if (options.length === 0) {
+            throw new Error('No variants are available');
+        }
+        else if (options.length === 1) {
+            // If only one option we will skip ahead and save the document with the only variant available:
+            variantIds.push(UmbVariantId.Create(options[0]));
         }
+        else {
+            // If there are multiple variants, we will open the modal to let the user pick which variants to publish.
+            const modalManagerContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+            const result = await modalManagerContext
+                .open(this, UMB_DOCUMENT_PUBLISH_MODAL, {
+                data: {
+                    options,
+                },
+                value: { selection: selected },
+            })
+                .onSubmit()
+                .catch(() => undefined);
+            if (!result?.selection.length || !unique)
+                return;
+            variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
+        }
+        const saveData = this.#buildSaveData(variantIds);
+        // Create the validation repository if it does not exist. (we first create this here when we need it) [NL]
+        this.#validationRepository ??= new UmbDocumentValidationRepository(this);
+        if (this.getIsNew()) {
+            const parent = this.#parent.getValue();
+            if (!parent)
+                throw new Error('Parent is not set');
+            this.#serverValidation.askServerForValidation(saveData, this.#validationRepository.validateCreate(saveData, parent.unique));
+        }
+        else {
+            this.#serverValidation.askServerForValidation(saveData, this.#validationRepository.validateSave(saveData));
+        }
+        // TODO: Only validate the specified selection.. [NL]
+        return this.validateAndSubmit(async () => {
+            return this.#performSaveAndPublish(variantIds, saveData);
+        }, async () => {
+            // If data of the selection is not valid Then just save:
+            await this.#performSaveOrCreate(saveData);
+            // Notifying that the save was successful, but we did not publish, which is what we want to symbolize here. [NL]
+            const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+            // TODO: Get rid of the save notification.
+            // TODO: Translate this message [NL]
+            notificationContext.peek('danger', {
+                data: { message: 'Document was not published, but we saved it for you.' },
+            });
+            // Reject even thought the save was successful, but we did not publish, which is what we want to symbolize here. [NL]
+            return await Promise.reject();
+        });
+    }
+    async #performSaveAndPublish(variantIds, saveData) {
+        const unique = this.getUnique();
+        if (!unique)
+            throw new Error('Unique is missing');
+        await this.#performSaveOrCreate(saveData);
+        await this.publishingRepository.publish(unique, variantIds.map((variantId) => ({ variantId })));
+    }
+    async #handleSave() {
+        const { options, selected } = await this.#determineVariantOptions();
+        let variantIds = [];
+        // If there is only one variant, we don't need to open the modal.
+        if (options.length === 0) {
+            throw new Error('No variants are available');
+        }
+        else if (options.length === 1) {
+            // If only one option we will skip ahead and save the document with the only variant available:
+            variantIds.push(UmbVariantId.Create(options[0]));
+        }
+        else {
+            // If there are multiple variants, we will open the modal to let the user pick which variants to save.
+            const modalManagerContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
+            const result = await modalManagerContext
+                .open(this, UMB_DOCUMENT_SAVE_MODAL, {
+                data: {
+                    options,
+                },
+                value: { selection: selected },
+            })
+                .onSubmit()
+                .catch(() => undefined);
+            if (!result?.selection.length)
+                return;
+            variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
+        }
+        const saveData = this.#buildSaveData(variantIds);
+        return await this.#performSaveOrCreate(saveData);
     }
     requestSubmit() {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_handleSave).call(this);
+        return this.#handleSave();
     }
     submit() {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_handleSave).call(this);
+        return this.#handleSave();
     }
     invalidSubmit() {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_handleSave).call(this);
+        return this.#handleSave();
     }
     async publish() {
         throw new Error('Method not implemented.');
     }
+    async saveAndPreview() {
+        return this.#handleSaveAndPreview();
+    }
     async saveAndPublish() {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_handleSaveAndPublish).call(this);
+        return this.#handleSaveAndPublish();
     }
     async schedule() {
-        const { options, selected } = await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_determineVariantOptions).call(this);
+        const { options, selected } = await this.#determineVariantOptions();
         const modalManagerContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
         const result = await modalManagerContext
             .open(this, UMB_DOCUMENT_SCHEDULE_MODAL, {
@@ -345,7 +657,7 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
         new UmbUnpublishDocumentEntityAction(this, { unique, entityType, meta: {} }).execute();
     }
     async publishWithDescendants() {
-        const { options, selected } = await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_determineVariantOptions).call(this);
+        const { options, selected } = await this.#determineVariantOptions();
         const modalManagerContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
         const result = await modalManagerContext
             .open(this, UMB_DOCUMENT_PUBLISH_WITH_DESCENDANTS_MODAL, {
@@ -384,274 +696,11 @@ export class UmbDocumentWorkspaceContext extends UmbSubmittableWorkspaceContextB
         return new UmbDocumentPropertyDataContext(host, this, variantId);
     }
     destroy() {
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").destroy();
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").destroy();
+        this.#persistedData.destroy();
+        this.#currentData.destroy();
         this.structure.destroy();
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_languageRepository, "f").destroy();
+        this.#languageRepository.destroy();
         super.destroy();
     }
 }
-_UmbDocumentWorkspaceContext_parent = new WeakMap(), _UmbDocumentWorkspaceContext_persistedData = new WeakMap(), _UmbDocumentWorkspaceContext_currentData = new WeakMap(), _UmbDocumentWorkspaceContext_getDataPromise = new WeakMap(), _UmbDocumentWorkspaceContext_languageRepository = new WeakMap(), _UmbDocumentWorkspaceContext_languages = new WeakMap(), _UmbDocumentWorkspaceContext_serverValidation = new WeakMap(), _UmbDocumentWorkspaceContext_serverValidationValuesTranslator = new WeakMap(), _UmbDocumentWorkspaceContext_validationRepository = new WeakMap(), _UmbDocumentWorkspaceContext_blueprintRepository = new WeakMap(), _UmbDocumentWorkspaceContext_varies = new WeakMap(), _UmbDocumentWorkspaceContext_entityContext = new WeakMap(), _UmbDocumentWorkspaceContext_instances = new WeakSet(), _UmbDocumentWorkspaceContext_onStoreChange = function _UmbDocumentWorkspaceContext_onStoreChange(entity) {
-    if (!entity) {
-        //TODO: This solution is alright for now. But reconsider when we introduce signal-r
-        history.pushState(null, '', 'section/content');
-    }
-}, _UmbDocumentWorkspaceContext_calculateChangedVariants = function _UmbDocumentWorkspaceContext_calculateChangedVariants() {
-    const persisted = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").getValue();
-    const current = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").getValue();
-    if (!current)
-        throw new Error('Current data is missing');
-    const changedVariants = current?.variants.map((variant) => {
-        const persistedVariant = persisted?.variants.find((x) => UmbVariantId.Create(variant).compare(x));
-        return {
-            culture: variant.culture,
-            segment: variant.segment,
-            equal: persistedVariant ? jsonStringComparison(variant, persistedVariant) : false,
-        };
-    });
-    const changedProperties = current?.values.map((value) => {
-        const persistedValues = persisted?.values.find((x) => UmbVariantId.Create(value).compare(x));
-        return {
-            culture: value.culture,
-            segment: value.segment,
-            equal: persistedValues ? jsonStringComparison(value, persistedValues) : false,
-        };
-    });
-    // calculate the variantIds of those who either have a change in properties or in variants:
-    return (changedVariants
-        ?.concat(changedProperties ?? [])
-        .filter((x) => x.equal === false)
-        .map((x) => new UmbVariantId(x.culture, x.segment)) ?? []);
-}, _UmbDocumentWorkspaceContext_updateVariantData = function _UmbDocumentWorkspaceContext_updateVariantData(variantId, update) {
-    const currentData = this.getData();
-    if (!currentData)
-        throw new Error('Data is missing');
-    if (__classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_varies, "f") === true) {
-        // If variant Id is invariant, we don't to have the variant appended to our data.
-        if (variantId.isInvariant())
-            return;
-        const variant = currentData.variants.find((x) => variantId.compare(x));
-        const newVariants = appendToFrozenArray(currentData.variants, {
-            state: null,
-            name: '',
-            publishDate: null,
-            createDate: null,
-            updateDate: null,
-            ...variantId.toObject(),
-            ...variant,
-            ...update,
-        }, (x) => variantId.compare(x));
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").update({ variants: newVariants });
-    }
-    else if (__classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_varies, "f") === false) {
-        // TODO: Beware about segments, in this case we need to also consider segments, if its allowed to vary by segments.
-        const invariantVariantId = UmbVariantId.CreateInvariant();
-        const variant = currentData.variants.find((x) => invariantVariantId.compare(x));
-        // Cause we are invariant, we will just overwrite all variants with this one:
-        const newVariants = [
-            {
-                state: null,
-                name: '',
-                publishDate: null,
-                createDate: null,
-                updateDate: null,
-                ...invariantVariantId.toObject(),
-                ...variant,
-                ...update,
-            },
-        ];
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").update({ variants: newVariants });
-    }
-    else {
-        throw new Error('Varies by culture is missing');
-    }
-}, _UmbDocumentWorkspaceContext_determineVariantOptions = async function _UmbDocumentWorkspaceContext_determineVariantOptions() {
-    const activeVariants = this.splitView.getActiveVariants();
-    const activeVariantIds = activeVariants.map((activeVariant) => UmbVariantId.Create(activeVariant));
-    // TODO: We need to filter the selected array, so it only contains one of each variantId. [NL]
-    const changedVariantIds = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_calculateChangedVariants).call(this);
-    const selected = activeVariantIds.concat(changedVariantIds);
-    // Selected can contain entries that are not part of the options, therefor the modal filters selection based on options.
-    const options = await firstValueFrom(this.variantOptions);
-    return {
-        options,
-        selected: selected.map((x) => x.toString()).filter((v, i, a) => a.indexOf(v) === i),
-    };
-}, _UmbDocumentWorkspaceContext_buildSaveData = function _UmbDocumentWorkspaceContext_buildSaveData(selectedVariants) {
-    const data = this.getData();
-    if (!data)
-        throw new Error('Data is missing');
-    if (!data.unique)
-        throw new Error('Unique is missing');
-    const invariantVariantId = UmbVariantId.CreateInvariant();
-    if (__classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_varies, "f") === false) {
-        // If we do not vary, we wil just do this for the invariant variant id.
-        selectedVariants = [invariantVariantId];
-    }
-    const persistedData = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").getValue();
-    const variantIdsToParseForValues = [...selectedVariants];
-    if (__classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_varies, "f") === true) {
-        // If we vary then We need to include the invariant variant id for invariant values to be saved, as we always want to save the invariant values.
-        variantIdsToParseForValues.push(invariantVariantId);
-    }
-    // Combine data and persisted data depending on the selectedVariants. Always use the invariant values from the data.
-    // loops over each entry in values, determine wether the value should be from the data or the persisted data, depending on wether its a selectedVariant or an invariant value.
-    // loops over each entry in variants, determine wether the variant should be from the data or the persisted data, depending on the selectedVariants.
-    return {
-        ...data,
-        values: data.values
-            .map((value) => {
-            // Should this value be saved?
-            if (variantIdsToParseForValues.some((x) => x.compare(value))) {
-                return value;
-            }
-            else {
-                // If not, then we will find the value in the persisted data and use that instead.
-                return persistedData?.values.find((x) => x.alias === value.alias && x.culture === value.culture && x.segment === value.segment);
-            }
-        })
-            .filter((x) => x !== undefined),
-        variants: data.variants
-            .map((variant) => {
-            // Should this value be saved?
-            if (selectedVariants.some((x) => x.compare(variant))) {
-                return variant;
-            }
-            else {
-                // If not we will find the value in the persisted data and use that instead.
-                return persistedData?.variants.find((x) => x.culture === variant.culture && x.segment === variant.segment);
-            }
-        })
-            .filter((x) => x !== undefined),
-    };
-}, _UmbDocumentWorkspaceContext_performSaveOrCreate = async function _UmbDocumentWorkspaceContext_performSaveOrCreate(saveData) {
-    if (this.getIsNew()) {
-        const parent = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_parent, "f").getValue();
-        if (!parent)
-            throw new Error('Parent is not set');
-        const { data, error } = await this.repository.create(saveData, parent.unique);
-        if (!data || error) {
-            console.error('Error creating document', error);
-            throw new Error('Error creating document');
-        }
-        this.setIsNew(false);
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").setValue(data);
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").setValue(data);
-        // TODO: this might not be the right place to alert the tree, but it works for now
-        const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
-        const event = new UmbRequestReloadTreeItemChildrenEvent({
-            entityType: parent.entityType,
-            unique: parent.unique,
-        });
-        eventContext.dispatchEvent(event);
-    }
-    else {
-        const { data, error } = await this.repository.save(saveData);
-        if (!data || error) {
-            console.error('Error saving document', error);
-            throw new Error('Error saving document');
-        }
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_persistedData, "f").setValue(data);
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_currentData, "f").setValue(data);
-        const eventContext = await this.getContext(UMB_ACTION_EVENT_CONTEXT);
-        const event = new UmbRequestReloadStructureForEntityEvent({
-            unique: this.getUnique(),
-            entityType: this.getEntityType(),
-        });
-        eventContext.dispatchEvent(event);
-    }
-}, _UmbDocumentWorkspaceContext_handleSaveAndPublish = async function _UmbDocumentWorkspaceContext_handleSaveAndPublish() {
-    const unique = this.getUnique();
-    if (!unique)
-        throw new Error('Unique is missing');
-    let variantIds = [];
-    const { options, selected } = await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_determineVariantOptions).call(this);
-    // If there is only one variant, we don't need to open the modal.
-    if (options.length === 0) {
-        throw new Error('No variants are available');
-    }
-    else if (options.length === 1) {
-        // If only one option we will skip ahead and save the document with the only variant available:
-        variantIds.push(UmbVariantId.Create(options[0]));
-    }
-    else {
-        // If there are multiple variants, we will open the modal to let the user pick which variants to publish.
-        const modalManagerContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
-        const result = await modalManagerContext
-            .open(this, UMB_DOCUMENT_PUBLISH_MODAL, {
-            data: {
-                options,
-            },
-            value: { selection: selected },
-        })
-            .onSubmit()
-            .catch(() => undefined);
-        if (!result?.selection.length || !unique)
-            return;
-        variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
-    }
-    const saveData = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_buildSaveData).call(this, variantIds);
-    // Create the validation repository if it does not exist. (we first create this here when we need it) [NL]
-    __classPrivateFieldSet(this, _UmbDocumentWorkspaceContext_validationRepository, __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_validationRepository, "f") ?? new UmbDocumentValidationRepository(this), "f");
-    if (this.getIsNew()) {
-        const parent = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_parent, "f").getValue();
-        if (!parent)
-            throw new Error('Parent is not set');
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_serverValidation, "f").askServerForValidation(saveData, __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_validationRepository, "f").validateCreate(saveData, parent.unique));
-    }
-    else {
-        __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_serverValidation, "f").askServerForValidation(saveData, __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_validationRepository, "f").validateSave(saveData));
-    }
-    // TODO: Only validate the specified selection.. [NL]
-    return this.validateAndSubmit(async () => {
-        return __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_performSaveAndPublish).call(this, variantIds, saveData);
-    }, async () => {
-        // If data of the selection is not valid Then just save:
-        await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_performSaveOrCreate).call(this, saveData);
-        // Notifying that the save was successful, but we did not publish, which is what we want to symbolize here. [NL]
-        const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
-        // TODO: Get rid of the save notification.
-        // TODO: Translate this message [NL]
-        notificationContext.peek('danger', {
-            data: { message: 'Document was not published, but we saved it for you.' },
-        });
-        // Reject even thought the save was successful, but we did not publish, which is what we want to symbolize here. [NL]
-        return await Promise.reject();
-    });
-}, _UmbDocumentWorkspaceContext_performSaveAndPublish = async function _UmbDocumentWorkspaceContext_performSaveAndPublish(variantIds, saveData) {
-    const unique = this.getUnique();
-    if (!unique)
-        throw new Error('Unique is missing');
-    await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_performSaveOrCreate).call(this, saveData);
-    await this.publishingRepository.publish(unique, variantIds.map((variantId) => ({ variantId })));
-}, _UmbDocumentWorkspaceContext_handleSave = async function _UmbDocumentWorkspaceContext_handleSave() {
-    const { options, selected } = await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_determineVariantOptions).call(this);
-    let variantIds = [];
-    // If there is only one variant, we don't need to open the modal.
-    if (options.length === 0) {
-        throw new Error('No variants are available');
-    }
-    else if (options.length === 1) {
-        // If only one option we will skip ahead and save the document with the only variant available:
-        variantIds.push(UmbVariantId.Create(options[0]));
-    }
-    else {
-        // If there are multiple variants, we will open the modal to let the user pick which variants to save.
-        const modalManagerContext = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
-        const result = await modalManagerContext
-            .open(this, UMB_DOCUMENT_SAVE_MODAL, {
-            data: {
-                options,
-            },
-            value: { selection: selected },
-        })
-            .onSubmit()
-            .catch(() => undefined);
-        if (!result?.selection.length)
-            return;
-        variantIds = result?.selection.map((x) => UmbVariantId.FromString(x)) ?? [];
-    }
-    const saveData = __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_buildSaveData).call(this, variantIds);
-    return await __classPrivateFieldGet(this, _UmbDocumentWorkspaceContext_instances, "m", _UmbDocumentWorkspaceContext_performSaveOrCreate).call(this, saveData);
-};
 export default UmbDocumentWorkspaceContext;