@umbraco-cms/backoffice 18.3.0-rc → 19.0.0-beta1

package/dist-cms/packages/core/workspace/controllers/workspace-variant-options.controller.js

@@ -0,0 +1,168 @@
+import { UmbControllerBase } from '../../../../libs/class-api/index.js';
+import { UmbVariantId, } from '../../variant/index.js';
+import { mergeObservables, UmbArrayState } from '../../../../libs/observable-api/index.js';
+import { map } from '../../../../external/rxjs/index.js';
+/**
+ * Manages the variant options of a workspace: the options derived from the variation of the entity and the
+ * available languages, plus any options added by other extensions, like segments.
+ * @template VariantModelType - The variant model of the entity.
+ * @template VariantOptionModelType - The variant option model exposed to consumers.
+ */
+export class UmbWorkspaceVariantOptionsController extends UmbControllerBase {
+    /* Languages */
+    #languages;
+    getLanguages() {
+        return this.#languages.getValue();
+    }
+    #variantOptions;
+    #currentCoreUniques;
+    #warnedUniques;
+    #warnUnresolvedLanguage(unique) {
+        if (this.#warnedUniques.has(unique))
+            return;
+        this.#warnedUniques.add(unique);
+        console.warn(`Variant option "${unique}" is left out, as its language could not be found.`);
+    }
+    constructor(host, varyByCulture, varyBySegment, variants, languages) {
+        super(host);
+        /* Languages */
+        this.#languages = new UmbArrayState(undefined, (x) => x.unique);
+        /**
+         * @private
+         * @description - Should not be used by external code.
+         * @internal
+         */
+        this.languages = this.#languages.asObservable();
+        this.#variantOptions = new UmbArrayState(undefined, (x) => x.unique);
+        /**
+         * The variant options with their language resolved. Options whose language cannot be found are left out. Emits `undefined` until the variation of the entity and the languages are known.
+         */
+        this.variantOptions = mergeObservables([this.#variantOptions.asObservable(), this.languages], ([option, languages]) => {
+            if (option === undefined || languages === undefined)
+                return undefined;
+            const defaultLang = languages.find((x) => x.isDefault);
+            return option.flatMap((opt) => {
+                const language = opt.culture ? languages.find((x) => x.unique === opt.culture) : defaultLang;
+                if (!language) {
+                    this.#warnUnresolvedLanguage(opt.unique);
+                    return [];
+                }
+                return [{ ...opt, language }];
+            });
+        });
+        this.#warnedUniques = new Set();
+        this.observe(languages, (languages) => {
+            this.#languages.setValue(languages);
+        }, null);
+        this.observe(mergeObservables([varyByCulture, varyBySegment, variants, this.languages], (sources) => sources), ([varyByCulture, varyBySegment, variants, languages]) => {
+            const newVariantOptions = this.#processLanguageVariantOptions(varyByCulture, varyBySegment, variants, languages);
+            // Still loading, keep what we have until the core options can be computed.
+            if (newVariantOptions === undefined)
+                return;
+            this.#variantOptions.mute();
+            if (newVariantOptions) {
+                // Figure out which to be removed:
+                const removedVariantOptions = this.#currentCoreUniques?.filter((unique) => !newVariantOptions.some((newOption) => newOption.unique === unique));
+                if (removedVariantOptions) {
+                    this.#variantOptions.remove(removedVariantOptions);
+                }
+                this.#variantOptions.append(newVariantOptions);
+            }
+            else if (this.#currentCoreUniques) {
+                // Since no options, then remove all previous ones:
+                this.#variantOptions.remove(this.#currentCoreUniques);
+            }
+            this.#currentCoreUniques = newVariantOptions?.map((x) => x.unique) ?? [];
+            this.#variantOptions.unmute();
+        }, null);
+    }
+    #processLanguageVariantOptions(varyByCulture, varyBySegment, variants, languages) {
+        // Are we in a loading phase?
+        if (languages === undefined || varyByCulture === undefined || varyBySegment === undefined) {
+            return undefined;
+        }
+        const varies = varyByCulture || varyBySegment;
+        // No variation
+        if (!varies) {
+            return [
+                {
+                    variant: variants.find((x) => x.culture === null),
+                    culture: null,
+                    segment: null,
+                    unique: new UmbVariantId().toString(),
+                },
+            ];
+        }
+        // Only culture variation
+        if (varyByCulture && !varyBySegment) {
+            return languages.map((language) => {
+                return {
+                    variant: variants.find((x) => x.culture === language.unique),
+                    culture: language.unique,
+                    segment: null,
+                    unique: new UmbVariantId(language.unique).toString(),
+                };
+            });
+        }
+        // Only segment variation
+        if (!varyByCulture && varyBySegment) {
+            const invariantCulture = {
+                variant: variants.find((x) => x.culture === null),
+                culture: null,
+                segment: null,
+                unique: new UmbVariantId().toString(),
+            };
+            return [invariantCulture];
+        }
+        // Culture and segment variation
+        if (varyByCulture && varyBySegment) {
+            return languages.map((language) => {
+                return {
+                    variant: variants.find((x) => x.culture === language.unique),
+                    culture: language.unique,
+                    segment: null,
+                    unique: new UmbVariantId(language.unique).toString(),
+                };
+            });
+        }
+        return [];
+    }
+    #hasFilter;
+    // TODO: Remove this feature in v.21
+    /**
+     * @deprecated - it is not possible to filter variant options from v.21.
+     * @param {(option: UmbEntityVariantOptionSourceModel<VariantOptionModelType>) => boolean} filter - The filter function to apply to variant options.
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    _internal_setOptionFilter(filter) {
+        if (this.#hasFilter)
+            return;
+        this.#hasFilter = true;
+        this.variantOptions = this.variantOptions.pipe(map((options) => options?.filter((option) => filter(option))));
+    }
+    /**
+     * Adds options next to the ones derived from the entity. An option with a unique that already exists replaces it.
+     * @param {Array<UmbEntityVariantOptionSourceModel<VariantOptionModelType>>} options - The options to add. The language is resolved from the culture, and an option whose language cannot be found is left out.
+     */
+    add(options) {
+        this.#variantOptions.append(options);
+    }
+    /**
+     * Removes options by their unique.
+     * @param {Array<string>} uniques - The uniques of the options to remove.
+     */
+    remove(uniques) {
+        this.#variantOptions.remove(uniques);
+    }
+    /**
+     * Removes and adds options in one step, so consumers only see the end result.
+     * @param {Array<string>} uniques - The uniques of the options to remove.
+     * @param {Array<UmbEntityVariantOptionSourceModel<VariantOptionModelType>>} options - The options to add.
+     */
+    replace(uniques, options) {
+        this.#variantOptions.mute();
+        this.remove(uniques);
+        this.add(options);
+        this.#variantOptions.unmute();
+    }
+}

package/dist-cms/packages/core/workspace/entity/entity-workspace-data-manager.d.ts

@@ -22,7 +22,6 @@ export declare class UmbEntityWorkspaceDataManager<ModelType> extends UmbControl
      * @memberof UmbEntityWorkspaceDataManager
      */
     readonly current: Observable<ModelType | undefined>;
-    protected _sortCurrentData<GivenType extends Partial<ModelType> = Partial<ModelType>>(persistedData: Partial<ModelType>, currentData: GivenType): GivenType;
     /**
      * Gets persisted data
      * @returns {(ModelType | undefined)} The persisted data.

package/dist-cms/packages/core/workspace/entity/entity-workspace-data-manager.js

@@ -23,10 +23,6 @@ export class UmbEntityWorkspaceDataManager extends UmbControllerBase {
          */
         this.current = this._current.asObservable();
     }
-    _sortCurrentData(persistedData, currentData) {
-        // do nothing.
-        return currentData;
-    }
     /**
      * Gets persisted data
      * @returns {(ModelType | undefined)} The persisted data.
@@ -75,12 +71,6 @@ export class UmbEntityWorkspaceDataManager extends UmbControllerBase {
      * @memberof UmbEntityWorkspaceDataManager
      */
     setCurrent(data) {
-        if (data) {
-            const persistedData = this._persisted.getValue();
-            if (persistedData) {
-                data = this._sortCurrentData(persistedData, data);
-            }
-        }
         this._current.setValue(data);
     }
     /**
@@ -89,12 +79,6 @@ export class UmbEntityWorkspaceDataManager extends UmbControllerBase {
      * @memberof UmbEntityWorkspaceDataManager
      */
     updateCurrent(partialData) {
-        if (partialData) {
-            const persistedData = this._persisted.getValue();
-            if (persistedData) {
-                partialData = this._sortCurrentData(persistedData, partialData);
-            }
-        }
         this._current.update(partialData);
     }
     /**

package/dist-cms/packages/core/workspace/entity-detail/entity-detail-workspace-base.d.ts

@@ -1,13 +1,14 @@
 import { UmbSubmittableWorkspaceContextBase } from '../submittable/index.js';
 import { UmbEntityWorkspaceDataManager } from '../entity/entity-workspace-data-manager.js';
 import type { UmbSubmittableTreeEntityWorkspaceContext } from '../contexts/tokens/index.js';
-import type { UmbEntityDetailWorkspaceContextArgs, UmbEntityDetailWorkspaceContextCreateArgs } from './types.js';
+import type { UmbEntityDetailIncomingDataHookMeta, UmbEntityDetailInitHookMeta, UmbEntityDetailWorkspaceContextArgs, UmbEntityDetailWorkspaceContextCreateArgs } from './types.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 import { type UmbEntityModel, type UmbEntityUnique } from '../../entity/index.js';
+import { UmbParallelHookController } from '../../../../libs/hook-api/index.js';
 import type { UmbDetailRepository, UmbRepositoryResponse, UmbRepositoryResponseWithAsObservable } from '../../repository/index.js';
 import { UmbStateManager } from '../../utils/index.js';
 import { UmbValidationContext } from '../../validation/index.js';
-export declare abstract class UmbEntityDetailWorkspaceContextBase<DetailModelType extends UmbEntityModel = UmbEntityModel, DetailRepositoryType extends UmbDetailRepository<DetailModelType> = UmbDetailRepository<DetailModelType>, CreateArgsType extends UmbEntityDetailWorkspaceContextCreateArgs<DetailModelType> = UmbEntityDetailWorkspaceContextCreateArgs<DetailModelType>> extends UmbSubmittableWorkspaceContextBase<DetailModelType> implements UmbSubmittableTreeEntityWorkspaceContext {
+export declare abstract class UmbEntityDetailWorkspaceContextBase<DetailModelType extends UmbEntityModel = UmbEntityModel, DetailRepositoryType extends UmbDetailRepository<DetailModelType> = UmbDetailRepository<DetailModelType>, CreateArgsType extends UmbEntityDetailWorkspaceContextCreateArgs<DetailModelType> = UmbEntityDetailWorkspaceContextCreateArgs<DetailModelType>, IncomingDataHookMetaType extends UmbEntityDetailIncomingDataHookMeta = UmbEntityDetailIncomingDataHookMeta> extends UmbSubmittableWorkspaceContextBase<DetailModelType> implements UmbSubmittableTreeEntityWorkspaceContext {
     #private;
     readonly IS_ENTITY_DETAIL_WORKSPACE_CONTEXT = true;
     /**
@@ -17,13 +18,22 @@ export declare abstract class UmbEntityDetailWorkspaceContextBase<DetailModelTyp
      */
     protected readonly _data: UmbEntityWorkspaceDataManager<DetailModelType>;
     readonly entityType: import("rxjs").Observable<string | undefined>;
-    readonly unique: import("rxjs").Observable<UmbEntityUnique>;
+    readonly unique: import("rxjs").Observable<UmbEntityUnique | undefined>;
     readonly data: import("rxjs").Observable<DetailModelType | undefined>;
     readonly persistedData: import("rxjs").Observable<DetailModelType | undefined>;
     readonly loading: UmbStateManager<import("../../utils/index.js").UmbState>;
     readonly forbidden: UmbStateManager<import("../../utils/index.js").UmbState>;
     protected _getDataPromise?: Promise<UmbRepositoryResponse<DetailModelType> | UmbRepositoryResponseWithAsObservable<DetailModelType>>;
     protected _detailRepository?: DetailRepositoryType;
+    /**
+     * Awaited while an entity is being loaded or scaffolded, in parallel with the potential request for its data.
+     * Anything that needs to take place during the initialization of the entity, like loading extensions and setup other hooks.
+     */
+    readonly initHook: UmbParallelHookController<UmbEntityDetailInitHookMeta>;
+    /**
+     * Runs on all incoming entity data before it is processed and sent to the Workspace Data Manager.
+     */
+    readonly incomingDataHook: UmbParallelHookController<IncomingDataHookMetaType>;
     readonly _internal_createUnderParent: import("rxjs").Observable<UmbEntityModel | undefined>;
     readonly _internal_createUnderParentEntityUnique: import("rxjs").Observable<UmbEntityUnique | undefined>;
     readonly _internal_createUnderParentEntityType: import("rxjs").Observable<string | undefined>;
@@ -49,6 +59,11 @@ export declare abstract class UmbEntityDetailWorkspaceContextBase<DetailModelTyp
      * logic — the default implementation always resolves to `undefined` (no known target).
      */
     readonly navigationParentItemPath: import("rxjs").Observable<string | undefined>;
+    /**
+     * Resolves once the workspace is initialized, meaning the detail repository is available.
+     * Overrides of `load` and `createScaffold` await this before executing the `initHook`.
+     */
+    protected get _initialized(): Promise<void>;
     constructor(host: UmbControllerHost, args: UmbEntityDetailWorkspaceContextArgs);
     /**
      * Resolves where a "back to parent" navigation should go, given the entity's current parent item (or
@@ -108,11 +123,12 @@ export declare abstract class UmbEntityDetailWorkspaceContextBase<DetailModelTyp
      */
     loadWithoutPersist(): Promise<DetailModelType>;
     /**
-     * Method to check if the workspace data is loaded.
-     * @returns { Promise<UmbRepositoryResponse<DetailModelType> | UmbRepositoryResponseWithAsObservable<DetailModelType>> | undefined } true if the workspace data is loaded.
+     * Resolves once nothing is loading, meaning an ongoing load or scaffold has finished and its data has been applied.
+     * Called right after `load` or `createScaffold` has been started, it waits for that to finish.
+     * @returns {Promise<void>} A promise that resolves when the workspace is no longer loading.
      * @memberof UmbEntityDetailWorkspaceContextBase
      */
-    isLoaded(): Promise<any> | undefined;
+    isLoaded(): Promise<void>;
     /**
      * Create a data scaffold
      * @param {CreateArgsType} args The arguments to create the scaffold.

package/dist-cms/packages/core/workspace/entity-detail/entity-detail-workspace-base.js

@@ -8,7 +8,9 @@ import { UMB_DISCARD_CHANGES_MODAL, umbOpenModal } from '../../modal/index.js';
 import { UmbObjectState, UmbStringState } from '../../../../libs/observable-api/index.js';
 import { UmbEntityUpdatedEvent, UmbRequestReloadChildrenOfEntityEvent, UmbRequestReloadStructureForEntityEvent, } from '../../entity-action/index.js';
 import { UmbExtensionApiInitializer } from '../../../../libs/extension-api/index.js';
+import { UmbParallelHookController } from '../../../../libs/hook-api/index.js';
 import { umbExtensionsRegistry } from '../../extension-registry/index.js';
+import { filter, firstValueFrom } from '../../../../external/rxjs/index.js';
 import { UmbStateManager } from '../../utils/index.js';
 import { UmbValidationContext } from '../../validation/index.js';
 import { UmbId } from '../../id/index.js';
@@ -23,6 +25,13 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
     #initResolver;
     #initialized;
     #init;
+    /**
+     * Resolves once the workspace is initialized, meaning the detail repository is available.
+     * Overrides of `load` and `createScaffold` await this before executing the `initHook`.
+     */
+    get _initialized() {
+        return this.#init;
+    }
     constructor(host, args) {
         super(host, args.workspaceAlias);
         // Just for context token safety:
@@ -40,6 +49,15 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
         this.persistedData = this._data.persisted;
         this.loading = new UmbStateManager(this);
         this.forbidden = new UmbStateManager(this);
+        /**
+         * Awaited while an entity is being loaded or scaffolded, in parallel with the potential request for its data.
+         * Anything that needs to take place during the initialization of the entity, like loading extensions and setup other hooks.
+         */
+        this.initHook = new UmbParallelHookController(this);
+        /**
+         * Runs on all incoming entity data before it is processed and sent to the Workspace Data Manager.
+         */
+        this.incomingDataHook = new UmbParallelHookController(this);
         this.#createUnderParent = new UmbObjectState(undefined);
         // eslint-disable-next-line @typescript-eslint/naming-convention
         this._internal_createUnderParent = this.#createUnderParent.asObservable();
@@ -225,29 +243,38 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
         this.setIsNew(false);
         this.#entityContext.setUnique(unique);
         this.loading.addState({ unique: LOADING_STATE_UNIQUE, message: `Loading ${this.getEntityType()} Details` });
-        await this.#init;
-        this._getDataPromise = this._detailRepository.requestByUnique(unique);
-        const response = (await this._getDataPromise);
-        const { data, error, asObservable } = response;
-        if (error) {
-            this.removeUmbControllerByAlias('umbEntityDetailTypeStoreObserver');
-            if (UmbApiError.isUmbApiError(error)) {
-                if (error.status === 401 || error.status === 403) {
-                    this.forbidden.addState({ unique: FORBIDDEN_STATE_UNIQUE, message: error.message });
+        try {
+            await this.#init;
+            const loading = this.initHook.execute({
+                entityType: this.getEntityType(),
+                unique,
+                isNew: false,
+            });
+            this._getDataPromise = this._detailRepository.requestByUnique(unique);
+            const [response] = (await Promise.all([this._getDataPromise, loading]));
+            const { data, error, asObservable } = response;
+            if (error) {
+                this.removeUmbControllerByAlias('umbEntityDetailTypeStoreObserver');
+                if (UmbApiError.isUmbApiError(error)) {
+                    if (error.status === 401 || error.status === 403) {
+                        this.forbidden.addState({ unique: FORBIDDEN_STATE_UNIQUE, message: error.message });
+                    }
                 }
             }
+            else if (data) {
+                const processedData = await this._processIncomingData(data);
+                this._data.setPersisted(processedData);
+                this._data.setCurrent(processedData);
+                this.observe(asObservable?.(), (entity) => {
+                    if (!entity)
+                        this._data.clear();
+                }, 'umbEntityDetailTypeStoreObserver');
+            }
+            return response;
         }
-        else if (data) {
-            const processedData = await this._processIncomingData(data);
-            this._data.setPersisted(processedData);
-            this._data.setCurrent(processedData);
-            this.observe(asObservable?.(), (entity) => {
-                if (!entity)
-                    this._data.clear();
-            }, 'umbEntityDetailTypeStoreObserver');
+        finally {
+            this.loading.removeState(LOADING_STATE_UNIQUE);
         }
-        this.loading.removeState(LOADING_STATE_UNIQUE);
-        return response;
     }
     /**
      * Reload the workspace data
@@ -279,12 +306,13 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
         return await this._processIncomingData(data);
     }
     /**
-     * Method to check if the workspace data is loaded.
-     * @returns { Promise<UmbRepositoryResponse<DetailModelType> | UmbRepositoryResponseWithAsObservable<DetailModelType>> | undefined } true if the workspace data is loaded.
+     * Resolves once nothing is loading, meaning an ongoing load or scaffold has finished and its data has been applied.
+     * Called right after `load` or `createScaffold` has been started, it waits for that to finish.
+     * @returns {Promise<void>} A promise that resolves when the workspace is no longer loading.
      * @memberof UmbEntityDetailWorkspaceContextBase
      */
     isLoaded() {
-        return this._getDataPromise;
+        return firstValueFrom(this.loading.isOff.pipe(filter((isOff) => isOff))).then(() => undefined);
     }
     /**
      * Create a data scaffold
@@ -298,26 +326,40 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
     async createScaffold(args) {
         this.resetState();
         this.loading.addState({ unique: LOADING_STATE_UNIQUE, message: `Creating ${this.getEntityType()} scaffold` });
-        await this.#init;
-        this._internal_setCreateUnderParent(args.parent);
-        const request = this._detailRepository.createScaffold(args.preset);
-        this._getDataPromise = request;
-        let { data } = await request;
-        if (data) {
-            data = await this._processIncomingData(data);
-            if (this.modalContext) {
-                // Notice if the preset comes with values, they will overwrite the scaffolded values... [NL]
-                data = { ...data, ...this.modalContext.data.preset };
-            }
+        try {
+            await this.#init;
+            this._internal_setCreateUnderParent(args.parent);
+            // Set before the loading hook runs, as extensions with an is-new condition cannot answer before this is known. [NL]
             this.setIsNew(true);
-            this.#entityContext.setUnique(data.unique);
-            this._data.setPersisted(data);
-            this._data.setCurrent(data);
+            const loading = this.initHook.execute({
+                entityType: this.getEntityType(),
+                unique: undefined,
+                isNew: true,
+            });
+            const request = this._detailRepository.createScaffold(args.preset);
+            this._getDataPromise = request;
+            let [{ data }] = await Promise.all([request, loading]);
+            if (data) {
+                data = await this._processIncomingData(data);
+                if (this.modalContext) {
+                    // Notice if the preset comes with values, they will overwrite the scaffolded values... [NL]
+                    data = { ...data, ...this.modalContext.data.preset };
+                }
+                this.#entityContext.setUnique(data.unique);
+                this._data.setPersisted(data);
+                this._data.setCurrent(data);
+            }
+            return data;
+        }
+        finally {
+            this.loading.removeState(LOADING_STATE_UNIQUE);
         }
-        this.loading.removeState(LOADING_STATE_UNIQUE);
-        return data;
     }
     async _processIncomingData(data) {
+        await this.incomingDataHook.execute({
+            entityType: this.getEntityType(),
+            unique: data.unique,
+        });
         return data;
     }
     async submit() {
@@ -452,6 +494,8 @@ export class UmbEntityDetailWorkspaceContextBase extends UmbSubmittableWorkspace
         this._detailRepository?.destroy();
         this.#entityContext.destroy();
         this._getDataPromise = undefined;
+        this.initHook.destroy();
+        this.incomingDataHook.destroy();
         super.destroy();
     }
 }

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

@@ -1,4 +1,4 @@
 import type { UmbWorkspaceContext } from '../workspace-context.interface.js';
 import type { UmbEntityDetailWorkspaceContextBase } from './entity-detail-workspace-base.js';
 import { UmbContextToken } from '../../../../libs/context-api/index.js';
-export declare const UMB_ENTITY_DETAIL_WORKSPACE_CONTEXT: UmbContextToken<UmbWorkspaceContext, UmbEntityDetailWorkspaceContextBase<import("../../entity/types.js").UmbEntityModel, import("../../repository/index.js").UmbDetailRepository<import("../../entity/types.js").UmbEntityModel>, import("./types.js").UmbEntityDetailWorkspaceContextCreateArgs<import("../../entity/types.js").UmbEntityModel>>>;
+export declare const UMB_ENTITY_DETAIL_WORKSPACE_CONTEXT: UmbContextToken<UmbWorkspaceContext, UmbEntityDetailWorkspaceContextBase<import("../../entity/types.js").UmbEntityModel, import("../../repository/index.js").UmbDetailRepository<import("../../entity/types.js").UmbEntityModel>, import("./types.js").UmbEntityDetailWorkspaceContextCreateArgs<import("../../entity/types.js").UmbEntityModel>, import("./types.js").UmbEntityDetailIncomingDataHookMeta>>;

package/dist-cms/packages/core/workspace/entity-detail/entity-named-detail-workspace-base.d.ts

@@ -8,7 +8,7 @@ import type { UmbNamedEntityModel } from '../../entity/index.js';
 export declare abstract class UmbEntityNamedDetailWorkspaceContextBase<NamedDetailModelType extends UmbNamedEntityModel = UmbNamedEntityModel, NamedDetailRepositoryType extends UmbDetailRepository<NamedDetailModelType> = UmbDetailRepository<NamedDetailModelType>, CreateArgsType extends UmbEntityDetailWorkspaceContextCreateArgs<NamedDetailModelType> = UmbEntityDetailWorkspaceContextCreateArgs<NamedDetailModelType>> extends UmbEntityDetailWorkspaceContextBase<NamedDetailModelType, NamedDetailRepositoryType, CreateArgsType> implements UmbNamableWorkspaceContext {
     readonly IS_ENTITY_NAMED_DETAIL_WORKSPACE_CONTEXT = true;
     readonly name: import("rxjs").Observable<string | undefined>;
-    readonly nameWriteGuard: UmbNameWriteGuardManager;
+    readonly nameWriteGuard: UmbNameWriteGuardManager<import("../../utils/index.js").UmbGuardRule>;
     constructor(host: UmbControllerHost, args: UmbEntityDetailWorkspaceContextArgs);
     getName(): string | undefined;
     setName(name: string | undefined): void;

package/dist-cms/packages/core/workspace/entity-detail/types.d.ts

@@ -13,3 +13,33 @@ export interface UmbEntityDetailWorkspaceContextCreateArgs<DetailModelType> {
     parent: UmbEntityModel;
     preset?: UmbDeepPartialObject<DetailModelType>;
 }
+/**
+ * The meta passed to the methods of an entity detail workspace's `initHook`.
+ */
+export interface UmbEntityDetailInitHookMeta {
+    /**
+     * The entity type of the entity being loaded or scaffolded.
+     */
+    entityType: string;
+    /**
+     * The unique of the entity being loaded, or undefined when a new entity is being created and has no unique yet.
+     */
+    unique: string | null | undefined;
+    /**
+     * Whether the entity is being scaffolded, as opposed to loaded.
+     */
+    isNew: boolean;
+}
+/**
+ * The meta passed to the methods of an entity detail workspace's `incomingDataHook`.
+ */
+export interface UmbEntityDetailIncomingDataHookMeta {
+    /**
+     * The entity type of the incoming entity.
+     */
+    entityType: string;
+    /**
+     * The unique of the incoming entity.
+     */
+    unique: string | null;
+}

package/dist-cms/packages/core/workspace/kinds/default/default-workspace.context.js

@@ -8,6 +8,7 @@ export class UmbDefaultWorkspaceContext extends UmbContextBase {
         super(host, UMB_WORKSPACE_CONTEXT);
         this.#entityContext = new UmbEntityContext(this);
         this.view = new UmbViewContext(this, null);
+        this.#entityContext.setUnique(null);
     }
     set manifest(manifest) {
         this.workspaceAlias = manifest.alias;
@@ -18,7 +19,7 @@ export class UmbDefaultWorkspaceContext extends UmbContextBase {
         this.#entityContext.setUnique(unique);
     }
     getUnique() {
-        return this.#entityContext.getUnique();
+        return this.#entityContext.getUnique() ?? null;
     }
     setEntityType(entityType) {
         this.#entityContext.setEntityType(entityType);

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

@@ -1,2 +1,3 @@
 export * from './namable-workspace.context-token.js';
 export * from './name-write-guard.manager.js';
+export * from './variant-name-write-guard.manager.js';

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

@@ -1,2 +1,3 @@
 export * from './namable-workspace.context-token.js';
 export * from './name-write-guard.manager.js';
+export * from './variant-name-write-guard.manager.js';

package/dist-cms/packages/core/workspace/namable/name-write-guard.manager.d.ts

@@ -1,6 +1,7 @@
 import type { Observable } from '../../../../external/rxjs/index.js';
-import { UmbGuardManagerBase } from '../../utils/index.js';
-export declare class UmbNameWriteGuardManager extends UmbGuardManagerBase {
+import { UmbGuardManagerBase, type UmbGuardRule } from '../../utils/index.js';
+export declare class UmbNameWriteGuardManager<RuleType extends UmbGuardRule = UmbGuardRule> extends UmbGuardManagerBase<RuleType> {
     #private;
     isPermittedForName(): Observable<boolean>;
+    getIsPermittedForName(): boolean;
 }

package/dist-cms/packages/core/workspace/namable/name-write-guard.manager.js

@@ -6,6 +6,9 @@ export class UmbNameWriteGuardManager extends UmbGuardManagerBase {
             return this.#resolvePermission(rules) ?? fallback;
         });
     }
+    getIsPermittedForName() {
+        return this.#resolvePermission(this.getRules()) ?? this._getFallback();
+    }
     #resolvePermission(rules) {
         if (rules.some((rule) => rule.permitted === false)) {
             return false;

package/dist-cms/packages/core/workspace/namable/variant-name-write-guard.manager.d.ts

@@ -0,0 +1,29 @@
+import { UmbNameWriteGuardManager } from './name-write-guard.manager.js';
+import type { UmbVariantId } from '../../variant/index.js';
+import { type Observable } from '../../../../libs/observable-api/index.js';
+import { type UmbVariantGuardRule } from '../../utils/index.js';
+export type UmbVariantNameWriteGuardRule = UmbVariantGuardRule;
+/**
+ * Name write guard for variant workspaces. A rule without a `variantId` applies to every variant, and a rule that is
+ * not permitted takes precedence. Without a `variantId` the guard answers like {@link UmbNameWriteGuardManager}:
+ * only rules that are not bound to a variant apply.
+ * @class UmbVariantNameWriteGuardManager
+ * @augments {UmbNameWriteGuardManager<UmbVariantNameWriteGuardRule>}
+ */
+export declare class UmbVariantNameWriteGuardManager extends UmbNameWriteGuardManager<UmbVariantNameWriteGuardRule> {
+    #private;
+    /**
+     * Observe if the name is permitted to be written.
+     * @param {UmbVariantId} [variantId] - The variant to check. Omit to check the name outside of any variant.
+     * @returns {Observable<boolean>} - Observable that emits true if the name is permitted to be written, false otherwise
+     * @memberof UmbVariantNameWriteGuardManager
+     */
+    isPermittedForName(variantId?: UmbVariantId): Observable<boolean>;
+    /**
+     * Check if the name is permitted to be written.
+     * @param {UmbVariantId} [variantId] - The variant to check. Omit to check the name outside of any variant.
+     * @returns {boolean} - true if the name is permitted to be written, false otherwise
+     * @memberof UmbVariantNameWriteGuardManager
+     */
+    getIsPermittedForName(variantId?: UmbVariantId): boolean;
+}

package/dist-cms/packages/core/workspace/namable/variant-name-write-guard.manager.js

@@ -0,0 +1,43 @@
+import { UmbNameWriteGuardManager } from './name-write-guard.manager.js';
+import { mergeObservables } from '../../../../libs/observable-api/index.js';
+import { resolveVariantGuardPermission } from '../../utils/index.js';
+/**
+ * Name write guard for variant workspaces. A rule without a `variantId` applies to every variant, and a rule that is
+ * not permitted takes precedence. Without a `variantId` the guard answers like {@link UmbNameWriteGuardManager}:
+ * only rules that are not bound to a variant apply.
+ * @class UmbVariantNameWriteGuardManager
+ * @augments {UmbNameWriteGuardManager<UmbVariantNameWriteGuardRule>}
+ */
+export class UmbVariantNameWriteGuardManager extends UmbNameWriteGuardManager {
+    /**
+     * Observe if the name is permitted to be written.
+     * @param {UmbVariantId} [variantId] - The variant to check. Omit to check the name outside of any variant.
+     * @returns {Observable<boolean>} - Observable that emits true if the name is permitted to be written, false otherwise
+     * @memberof UmbVariantNameWriteGuardManager
+     */
+    isPermittedForName(variantId) {
+        return mergeObservables([this.rules, this._fallback], ([rules, fallback]) => {
+            return this.#resolvePermission(rules, variantId) ?? fallback;
+        });
+    }
+    /**
+     * Check if the name is permitted to be written.
+     * @param {UmbVariantId} [variantId] - The variant to check. Omit to check the name outside of any variant.
+     * @returns {boolean} - true if the name is permitted to be written, false otherwise
+     * @memberof UmbVariantNameWriteGuardManager
+     */
+    getIsPermittedForName(variantId) {
+        return this.#resolvePermission(this.getRules(), variantId) ?? this._getFallback();
+    }
+    #resolvePermission(rules, variantId) {
+        if (variantId) {
+            return resolveVariantGuardPermission(rules, variantId);
+        }
+        const unboundRules = rules.filter((rule) => rule.variantId === undefined);
+        if (unboundRules.some((rule) => rule.permitted === false))
+            return false;
+        if (unboundRules.some((rule) => rule.permitted === true))
+            return true;
+        return undefined;
+    }
+}